// Type definitions for prettier 2.7 // Project: https://prettier.io // https://github.com/prettier/prettier // Definitions by: Ika <https://github.com/ikatyang> // Ifiok Jr. <https://github.com/ifiokjr> // Florian Imdahl <https://github.com/ffflorian> // Sosuke Suzuki <https://github.com/sosukesuzuki> // Christopher Quadflieg <https://github.com/Shinigami92> // Georgii Dolzhykov <https://github.com/thorn0> // JounQin <https://github.com/JounQin> // Chuah Chee Shian <https://github.com/shian15810> // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // Minimum TypeScript Version: 4.2 // Adding export {} here to shut off automatic exporting from index.d.ts. There // are quite a few utility types here that don't need to be shipped with the // exported module. export {}; // This utility is here to handle the case where you have an explicit union // between string literals and the generic string type. It would normally // resolve out to just the string type, but this generic LiteralUnion maintains // the intellisense of the original union. // // It comes from this issue: microsoft/TypeScript#29729: // https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227 export type LiteralUnion<T extends U, U = string> = T | (Pick<U, never> & { _?: never | undefined }); export type AST = any; export type Doc = doc.builders.Doc; // The type of elements that make up the given array T. type ArrayElement<T> = T extends Array<infer E> ? E : never; // A union of the properties of the given object that are arrays. type ArrayProperties<T> = { [K in keyof T]: NonNullable<T[K]> extends any[] ? K : never }[keyof T]; // A union of the properties of the given array T that can be used to index it. // If the array is a tuple, then that's going to be the explicit indices of the // array, otherwise it's going to just be number. type IndexProperties<T extends { length: number }> = IsTuple<T> extends true ? Exclude<Partial<T>['length'], T['length']> : number; // Effectively performing T[P], except that it's telling TypeScript that it's // safe to do this for tuples, arrays, or objects. type IndexValue<T, P> = T extends any[] ? (P extends number ? T[P] : never) : P extends keyof T ? T[P] : never; // Determines if an object T is an array like string[] (in which case this // evaluates to false) or a tuple like [string] (in which case this evaluates to // true). // eslint-disable-next-line @typescript-eslint/no-unused-vars type IsTuple<T> = T extends [] ? true : T extends [infer First, ...infer Remain] ? IsTuple<Remain> : false; type CallProperties<T> = T extends any[] ? IndexProperties<T> : keyof T; type IterProperties<T> = T extends any[] ? IndexProperties<T> : ArrayProperties<T>; type CallCallback<T, U> = (path: AstPath<T>, index: number, value: any) => U; type EachCallback<T> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => void; type MapCallback<T, U> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => U; // https://github.com/prettier/prettier/blob/main/src/common/ast-path.js export class AstPath<T = any> { constructor(value: T); stack: T[]; callParent<U>(callback: (path: this) => U, count?: number): U; getName(): PropertyKey | null; getValue(): T; getNode(count?: number): T | null; getParentNode(count?: number): T | null; match(...predicates: Array<(node: any, name: string | null, number: number | null) => boolean>): boolean; // For each of the tree walk functions (call, each, and map) this provides 5 // strict type signatures, along with a fallback at the end if you end up // calling more than 5 properties deep. This helps a lot with typing because // for the majority of cases you're calling fewer than 5 properties, so the // tree walk functions have a clearer understanding of what you're doing. // // Note that resolving these types is somewhat complicated, and it wasn't // even supported until TypeScript 4.2 (before it would just say that the // type instantiation was excessively deep and possibly infinite). call<U>(callback: CallCallback<T, U>): U; call<U, P1 extends CallProperties<T>>(callback: CallCallback<IndexValue<T, P1>, U>, prop1: P1): U; call<U, P1 extends keyof T, P2 extends CallProperties<T[P1]>>( callback: CallCallback<IndexValue<IndexValue<T, P1>, P2>, U>, prop1: P1, prop2: P2, ): U; call<U, P1 extends keyof T, P2 extends CallProperties<T[P1]>, P3 extends CallProperties<IndexValue<T[P1], P2>>>( callback: CallCallback<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, U>, prop1: P1, prop2: P2, prop3: P3, ): U; call< U, P1 extends keyof T, P2 extends CallProperties<T[P1]>, P3 extends CallProperties<IndexValue<T[P1], P2>>, P4 extends CallProperties<IndexValue<IndexValue<T[P1], P2>, P3>> >( callback: CallCallback<IndexValue<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, P4>, U>, prop1: P1, prop2: P2, prop3: P3, prop4: P4, ): U; call<U, P extends PropertyKey>( callback: CallCallback<any, U>, prop1: P, prop2: P, prop3: P, prop4: P, ...props: P[] ): U; each(callback: EachCallback<T>): void; each<P1 extends IterProperties<T>>(callback: EachCallback<IndexValue<T, P1>>, prop1: P1): void; each<P1 extends keyof T, P2 extends IterProperties<T[P1]>>( callback: EachCallback<IndexValue<IndexValue<T, P1>, P2>>, prop1: P1, prop2: P2, ): void; each<P1 extends keyof T, P2 extends IterProperties<T[P1]>, P3 extends IterProperties<IndexValue<T[P1], P2>>>( callback: EachCallback<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>>, prop1: P1, prop2: P2, prop3: P3, ): void; each< P1 extends keyof T, P2 extends IterProperties<T[P1]>, P3 extends IterProperties<IndexValue<T[P1], P2>>, P4 extends IterProperties<IndexValue<IndexValue<T[P1], P2>, P3>> >( callback: EachCallback<IndexValue<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, P4>>, prop1: P1, prop2: P2, prop3: P3, prop4: P4, ): void; each( callback: EachCallback<any[]>, prop1: PropertyKey, prop2: PropertyKey, prop3: PropertyKey, prop4: PropertyKey, ...props: PropertyKey[] ): void; map<U>(callback: MapCallback<T, U>): U[]; map<U, P1 extends IterProperties<T>>(callback: MapCallback<IndexValue<T, P1>, U>, prop1: P1): U[]; map<U, P1 extends keyof T, P2 extends IterProperties<T[P1]>>( callback: MapCallback<IndexValue<IndexValue<T, P1>, P2>, U>, prop1: P1, prop2: P2, ): U[]; map<U, P1 extends keyof T, P2 extends IterProperties<T[P1]>, P3 extends IterProperties<IndexValue<T[P1], P2>>>( callback: MapCallback<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, U>, prop1: P1, prop2: P2, prop3: P3, ): U[]; map< U, P1 extends keyof T, P2 extends IterProperties<T[P1]>, P3 extends IterProperties<IndexValue<T[P1], P2>>, P4 extends IterProperties<IndexValue<IndexValue<T[P1], P2>, P3>> >( callback: MapCallback<IndexValue<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, P4>, U>, prop1: P1, prop2: P2, prop3: P3, prop4: P4, ): U[]; map<U>( callback: MapCallback<any[], U>, prop1: PropertyKey, prop2: PropertyKey, prop3: PropertyKey, prop4: PropertyKey, ...props: PropertyKey[] ): U[]; } /** @deprecated `FastPath` was renamed to `AstPath` */ export type FastPath<T = any> = AstPath<T>; export type BuiltInParser = (text: string, options?: any) => AST; export type BuiltInParserName = | 'angular' | 'babel-flow' | 'babel-ts' | 'babel' | 'css' | 'espree' | 'flow' | 'glimmer' | 'graphql' | 'html' | 'json-stringify' | 'json' | 'json5' | 'less' | 'lwc' | 'markdown' | 'mdx' | 'meriyah' | 'scss' | 'typescript' | 'vue' | 'yaml'; export type BuiltInParsers = Record<BuiltInParserName, BuiltInParser>; export type CustomParser = (text: string, parsers: BuiltInParsers, options: Options) => AST; /** * For use in `.prettierrc.js`, `.prettierrc.cjs`, `prettier.config.js` or `prettier.config.cjs`. */ export interface Config extends Options { overrides?: Array<{ files: string | string[]; excludeFiles?: string | string[]; options?: Options; }>; } export interface Options extends Partial<RequiredOptions> {} export interface RequiredOptions extends doc.printer.Options { /** * Print semicolons at the ends of statements. * @default true */ semi: boolean; /** * Use single quotes instead of double quotes. * @default false */ singleQuote: boolean; /** * Use single quotes in JSX. * @default false */ jsxSingleQuote: boolean; /** * Print trailing commas wherever possible. * @default 'es5' */ trailingComma: 'none' | 'es5' | 'all'; /** * Print spaces between brackets in object literals. * @default true */ bracketSpacing: boolean; /** * Put the `>` of a multi-line HTML (HTML, JSX, Vue, Angular) element at the end of the last line instead of being * alone on the next line (does not apply to self closing elements). * @default false */ bracketSameLine: boolean; /** * Put the `>` of a multi-line JSX element at the end of the last line instead of being alone on the next line. * @default false * @deprecated use bracketSameLine instead */ jsxBracketSameLine: boolean; /** * Format only a segment of a file. * @default 0 */ rangeStart: number; /** * Format only a segment of a file. * @default Infinity */ rangeEnd: number; /** * Specify which parser to use. */ parser: LiteralUnion<BuiltInParserName> | CustomParser; /** * Specify the input filepath. This will be used to do parser inference. */ filepath: string; /** * Prettier can restrict itself to only format files that contain a special comment, called a pragma, at the top of the file. * This is very useful when gradually transitioning large, unformatted codebases to prettier. * @default false */ requirePragma: boolean; /** * Prettier can insert a special @format marker at the top of files specifying that * the file has been formatted with prettier. This works well when used in tandem with * the --require-pragma option. If there is already a docblock at the top of * the file then this option will add a newline to it with the @format marker. * @default false */ insertPragma: boolean; /** * By default, Prettier will wrap markdown text as-is since some services use a linebreak-sensitive renderer. * In some cases you may want to rely on editor/viewer soft wrapping instead, so this option allows you to opt out. * @default 'preserve' */ proseWrap: 'always' | 'never' | 'preserve'; /** * Include parentheses around a sole arrow function parameter. * @default 'always' */ arrowParens: 'avoid' | 'always'; /** * Provide ability to support new languages to prettier. */ plugins: Array<string | Plugin>; /** * Specify plugin directory paths to search for plugins if not installed in the same `node_modules` where prettier is located. */ pluginSearchDirs: string[] | false; /** * How to handle whitespaces in HTML. * @default 'css' */ htmlWhitespaceSensitivity: 'css' | 'strict' | 'ignore'; /** * Which end of line characters to apply. * @default 'lf' */ endOfLine: 'auto' | 'lf' | 'crlf' | 'cr'; /** * Change when properties in objects are quoted. * @default 'as-needed' */ quoteProps: 'as-needed' | 'consistent' | 'preserve'; /** * Whether or not to indent the code inside <script> and <style> tags in Vue files. * @default false */ vueIndentScriptAndStyle: boolean; /** * Control whether Prettier formats quoted code embedded in the file. * @default 'auto' */ embeddedLanguageFormatting: 'auto' | 'off'; /** * Enforce single attribute per line in HTML, Vue and JSX. * @default false */ singleAttributePerLine: boolean; } export interface ParserOptions<T = any> extends RequiredOptions { locStart: (node: T) => number; locEnd: (node: T) => number; originalText: string; } export interface Plugin<T = any> { languages?: SupportLanguage[] | undefined; parsers?: { [parserName: string]: Parser<T> } | undefined; printers?: { [astFormat: string]: Printer<T> } | undefined; options?: SupportOptions | undefined; defaultOptions?: Partial<RequiredOptions> | undefined; } export interface Parser<T = any> { parse: (text: string, parsers: { [parserName: string]: Parser }, options: ParserOptions<T>) => T; astFormat: string; hasPragma?: ((text: string) => boolean) | undefined; locStart: (node: T) => number; locEnd: (node: T) => number; preprocess?: ((text: string, options: ParserOptions<T>) => string) | undefined; } export interface Printer<T = any> { print(path: AstPath<T>, options: ParserOptions<T>, print: (path: AstPath<T>) => Doc, args?: unknown): Doc; embed?: | (( path: AstPath<T>, print: (path: AstPath<T>) => Doc, textToDoc: (text: string, options: Options) => Doc, options: ParserOptions<T>, ) => Doc | null) | undefined; insertPragma?: ((text: string) => string) | undefined; /** * @returns `null` if you want to remove this node * @returns `void` if you want to use modified newNode * @returns anything if you want to replace the node with it */ massageAstNode?: ((node: any, newNode: any, parent: any) => any) | undefined; hasPrettierIgnore?: ((path: AstPath<T>) => boolean) | undefined; canAttachComment?: ((node: T) => boolean) | undefined; isBlockComment?: ((node: T) => boolean) | undefined; willPrintOwnComments?: ((path: AstPath<T>) => boolean) | undefined; printComment?: ((commentPath: AstPath<T>, options: ParserOptions<T>) => Doc) | undefined; handleComments?: | { ownLine?: | (( commentNode: any, text: string, options: ParserOptions<T>, ast: T, isLastComment: boolean, ) => boolean) | undefined; endOfLine?: | (( commentNode: any, text: string, options: ParserOptions<T>, ast: T, isLastComment: boolean, ) => boolean) | undefined; remaining?: | (( commentNode: any, text: string, options: ParserOptions<T>, ast: T, isLastComment: boolean, ) => boolean) | undefined; } | undefined; } export interface CursorOptions extends Options { /** * Specify where the cursor is. */ cursorOffset: number; rangeStart?: never; rangeEnd?: never; } export interface CursorResult { formatted: string; cursorOffset: number; } /** * `format` is used to format text using Prettier. [Options](https://prettier.io/docs/en/options.html) may be provided to override the defaults. */ export function format(source: string, options?: Options): string; /** * `check` checks to see if the file has been formatted with Prettier given those options and returns a `Boolean`. * This is similar to the `--list-different` parameter in the CLI and is useful for running Prettier in CI scenarios. */ export function check(source: string, options?: Options): boolean; /** * `formatWithCursor` both formats the code, and translates a cursor position from unformatted code to formatted code. * This is useful for editor integrations, to prevent the cursor from moving when code is formatted. * * The `cursorOffset` option should be provided, to specify where the cursor is. This option cannot be used with `rangeStart` and `rangeEnd`. */ export function formatWithCursor(source: string, options: CursorOptions): CursorResult; export interface ResolveConfigOptions { /** * If set to `false`, all caching will be bypassed. */ useCache?: boolean | undefined; /** * Pass directly the path of the config file if you don't wish to search for it. */ config?: string | undefined; /** * If set to `true` and an `.editorconfig` file is in your project, * Prettier will parse it and convert its properties to the corresponding prettier configuration. * This configuration will be overridden by `.prettierrc`, etc. Currently, * the following EditorConfig properties are supported: * - indent_style * - indent_size/tab_width * - max_line_length */ editorconfig?: boolean | undefined; } /** * `resolveConfig` can be used to resolve configuration for a given source file, * passing its path as the first argument. The config search will start at the * file path and continue to search up the directory. * (You can use `process.cwd()` to start searching from the current directory). * * A promise is returned which will resolve to: * * - An options object, providing a [config file](https://prettier.io/docs/en/configuration.html) was found. * - `null`, if no file was found. * * The promise will be rejected if there was an error parsing the configuration file. */ export function resolveConfig(filePath: string, options?: ResolveConfigOptions): Promise<Options | null>; export namespace resolveConfig { function sync(filePath: string, options?: ResolveConfigOptions): Options | null; } /** * `resolveConfigFile` can be used to find the path of the Prettier configuration file, * that will be used when resolving the config (i.e. when calling `resolveConfig`). * * A promise is returned which will resolve to: * * - The path of the configuration file. * - `null`, if no file was found. * * The promise will be rejected if there was an error parsing the configuration file. */ export function resolveConfigFile(filePath?: string): Promise<string | null>; export namespace resolveConfigFile { function sync(filePath?: string): string | null; } /** * As you repeatedly call `resolveConfig`, the file system structure will be cached for performance. This function will clear the cache. * Generally this is only needed for editor integrations that know that the file system has changed since the last format took place. */ export function clearConfigCache(): void; export interface SupportLanguage { name: string; since?: string | undefined; parsers: BuiltInParserName[] | string[]; group?: string | undefined; tmScope?: string | undefined; aceMode?: string | undefined; codemirrorMode?: string | undefined; codemirrorMimeType?: string | undefined; aliases?: string[] | undefined; extensions?: string[] | undefined; filenames?: string[] | undefined; linguistLanguageId?: number | undefined; vscodeLanguageIds?: string[] | undefined; interpreters?: string[] | undefined; } export interface SupportOptionRange { start: number; end: number; step: number; } export type SupportOptionType = 'int' | 'boolean' | 'choice' | 'path'; export type CoreCategoryType = 'Config' | 'Editor' | 'Format' | 'Other' | 'Output' | 'Global' | 'Special'; export interface BaseSupportOption<Type extends SupportOptionType> { readonly name?: string | undefined; since: string; /** * Usually you can use {@link CoreCategoryType} */ category: string; /** * The type of the option. * * When passing a type other than the ones listed below, the option is * treated as taking any string as argument, and `--option <${type}>` will * be displayed in --help. */ type: Type; /** * Indicate that the option is deprecated. * * Use a string to add an extra message to --help for the option, * for example to suggest a replacement option. */ deprecated?: true | string | undefined; /** * Description to be displayed in --help. If omitted, the option won't be * shown at all in --help. */ description?: string | undefined; } export interface IntSupportOption extends BaseSupportOption<'int'> { default?: number | undefined; array?: false | undefined; range?: SupportOptionRange | undefined; } export interface IntArraySupportOption extends BaseSupportOption<'int'> { default?: Array<{ value: number[] }> | undefined; array: true; } export interface BooleanSupportOption extends BaseSupportOption<'boolean'> { default?: boolean | undefined; array?: false | undefined; description: string; oppositeDescription?: string | undefined; } export interface BooleanArraySupportOption extends BaseSupportOption<'boolean'> { default?: Array<{ value: boolean[] }> | undefined; array: true; } export interface ChoiceSupportOption<Value = any> extends BaseSupportOption<'choice'> { default?: Value | Array<{ since: string; value: Value }> | undefined; description: string; choices: Array<{ since?: string | undefined; value: Value; description: string; }>; } export interface PathSupportOption extends BaseSupportOption<'path'> { default?: string | undefined; array?: false | undefined; } export interface PathArraySupportOption extends BaseSupportOption<'path'> { default?: Array<{ value: string[] }> | undefined; array: true; } export type SupportOption = | IntSupportOption | IntArraySupportOption | BooleanSupportOption | BooleanArraySupportOption | ChoiceSupportOption | PathSupportOption | PathArraySupportOption; export interface SupportOptions extends Record<string, SupportOption> {} export interface SupportInfo { languages: SupportLanguage[]; options: SupportOption[]; } export interface FileInfoOptions { ignorePath?: string | undefined; withNodeModules?: boolean | undefined; plugins?: string[] | undefined; resolveConfig?: boolean | undefined; } export interface FileInfoResult { ignored: boolean; inferredParser: string | null; } export function getFileInfo(filePath: string, options?: FileInfoOptions): Promise<FileInfoResult>; export namespace getFileInfo { function sync(filePath: string, options?: FileInfoOptions): FileInfoResult; } /** * Returns an object representing the parsers, languages and file types Prettier supports for the current version. */ export function getSupportInfo(): SupportInfo; /** * `version` field in `package.json` */ export const version: string; // https://github.com/prettier/prettier/blob/main/src/common/util-shared.js export namespace util { interface SkipOptions { backwards?: boolean | undefined; } type Quote = "'" | '"'; function addDanglingComment(node: any, comment: any, marker: any): void; function addLeadingComment(node: any, comment: any): void; function addTrailingComment(node: any, comment: any): void; function getAlignmentSize(value: string, tabWidth: number, startIndex?: number): number; function getIndentSize(value: string, tabWidth: number): number; function getMaxContinuousCount(str: string, target: string): number; function getNextNonSpaceNonCommentCharacterIndex<N>( text: string, node: N, locEnd: (node: N) => number, ): number | false; function getStringWidth(text: string): number; function hasNewline(text: string, index: number, opts?: SkipOptions): boolean; function hasNewlineInRange(text: string, start: number, end: number): boolean; function hasSpaces(text: string, index: number, opts?: SkipOptions): boolean; function isNextLineEmpty<N>(text: string, node: N, locEnd: (node: N) => number): boolean; function isNextLineEmptyAfterIndex(text: string, index: number): boolean; function isPreviousLineEmpty<N>(text: string, node: N, locStart: (node: N) => number): boolean; function makeString(rawContent: string, enclosingQuote: Quote, unescapeUnnecessaryEscapes?: boolean): string; function skip(chars: string | RegExp): (text: string, index: number | false, opts?: SkipOptions) => number | false; function skipEverythingButNewLine(text: string, index: number | false, opts?: SkipOptions): number | false; function skipInlineComment(text: string, index: number | false): number | false; function skipNewline(text: string, index: number | false, opts?: SkipOptions): number | false; function skipSpaces(text: string, index: number | false, opts?: SkipOptions): number | false; function skipToLineEnd(text: string, index: number | false, opts?: SkipOptions): number | false; function skipTrailingComment(text: string, index: number | false): number | false; function skipWhitespace(text: string, index: number | false, opts?: SkipOptions): number | false; } // https://github.com/prettier/prettier/blob/main/src/document/index.js export namespace doc { namespace builders { type DocCommand = | Align | BreakParent | Concat | Cursor | Fill | Group | IfBreak | Indent | IndentIfBreak | Label | Line | LineSuffix | LineSuffixBoundary | Trim; type Doc = string | Doc[] | DocCommand; interface Align { type: 'align'; contents: Doc; n: number | string | { type: 'root' }; } interface BreakParent { type: 'break-parent'; } interface Concat { type: 'concat'; parts: Doc[]; } interface Cursor { type: 'cursor'; placeholder: symbol; } interface Fill { type: 'fill'; parts: Doc[]; } interface Group { type: 'group'; contents: Doc; break: boolean; expandedStates: Doc[]; } interface HardlineWithoutBreakParent extends Line { hard: true; } interface IfBreak { type: 'if-break'; breakContents: Doc; flatContents: Doc; } interface Indent { type: 'indent'; contents: Doc; } interface IndentIfBreak { type: 'indent-if-break'; } interface Label { type: 'label'; } interface Line { type: 'line'; soft?: boolean | undefined; hard?: boolean | undefined; literal?: boolean | undefined; } interface LineSuffix { type: 'line-suffix'; contents: Doc; } interface LineSuffixBoundary { type: 'line-suffix-boundary'; } interface LiterallineWithoutBreakParent extends Line { hard: true; literal: true; } interface Softline extends Line { soft: true; } interface Trim { type: 'trim'; } interface GroupOptions { shouldBreak?: boolean | undefined; id?: symbol | undefined; } function addAlignmentToDoc(doc: Doc, size: number, tabWidth: number): Doc; /** @see [align](https://github.com/prettier/prettier/blob/main/commands.md#align) */ function align(widthOrString: Align['n'], doc: Doc): Align; /** @see [breakParent](https://github.com/prettier/prettier/blob/main/commands.md#breakparent) */ const breakParent: BreakParent; /** * @see [concat](https://github.com/prettier/prettier/blob/main/commands.md#deprecated-concat) * @deprecated use `Doc[]` instead */ function concat(docs: Doc[]): Concat; /** @see [conditionalGroup](https://github.com/prettier/prettier/blob/main/commands.md#conditionalgroup) */ function conditionalGroup(alternatives: Doc[], options?: GroupOptions): Group; /** @see [dedent](https://github.com/prettier/prettier/blob/main/commands.md#dedent) */ function dedent(doc: Doc): Align; /** @see [dedentToRoot](https://github.com/prettier/prettier/blob/main/commands.md#dedenttoroot) */ function dedentToRoot(doc: Doc): Align; /** @see [fill](https://github.com/prettier/prettier/blob/main/commands.md#fill) */ function fill(docs: Doc[]): Fill; /** @see [group](https://github.com/prettier/prettier/blob/main/commands.md#group) */ function group(doc: Doc, opts?: GroupOptions): Group; /** @see [hardline](https://github.com/prettier/prettier/blob/main/commands.md#hardline) */ const hardline: Concat; /** @see [hardlineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent) */ const hardlineWithoutBreakParent: HardlineWithoutBreakParent; /** @see [ifBreak](https://github.com/prettier/prettier/blob/main/commands.md#ifbreak) */ function ifBreak(ifBreak: Doc, noBreak?: Doc, options?: { groupId?: symbol | undefined }): IfBreak; /** @see [indent](https://github.com/prettier/prettier/blob/main/commands.md#indent) */ function indent(doc: Doc): Indent; /** @see [indentIfBreak](https://github.com/prettier/prettier/blob/main/commands.md#indentifbreak) */ function indentIfBreak(doc: Doc, opts: { groupId: symbol; negate?: boolean | undefined }): IndentIfBreak; /** @see [join](https://github.com/prettier/prettier/blob/main/commands.md#join) */ function join(sep: Doc, docs: Doc[]): Concat; /** @see [label](https://github.com/prettier/prettier/blob/main/commands.md#label) */ function label(label: string, doc: Doc): Label; /** @see [line](https://github.com/prettier/prettier/blob/main/commands.md#line) */ const line: Line; /** @see [lineSuffix](https://github.com/prettier/prettier/blob/main/commands.md#linesuffix) */ function lineSuffix(suffix: Doc): LineSuffix; /** @see [lineSuffixBoundary](https://github.com/prettier/prettier/blob/main/commands.md#linesuffixboundary) */ const lineSuffixBoundary: LineSuffixBoundary; /** @see [literalline](https://github.com/prettier/prettier/blob/main/commands.md#literalline) */ const literalline: Concat; /** @see [literallineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent) */ const literallineWithoutBreakParent: LiterallineWithoutBreakParent; /** @see [markAsRoot](https://github.com/prettier/prettier/blob/main/commands.md#markasroot) */ function markAsRoot(doc: Doc): Align; /** @see [softline](https://github.com/prettier/prettier/blob/main/commands.md#softline) */ const softline: Softline; /** @see [trim](https://github.com/prettier/prettier/blob/main/commands.md#trim) */ const trim: Trim; /** @see [cursor](https://github.com/prettier/prettier/blob/main/commands.md#cursor) */ const cursor: Cursor; } namespace debug { function printDocToDebug(doc: Doc): string; } namespace printer { function printDocToString( doc: Doc, options: Options, ): { formatted: string; cursorNodeStart?: number | undefined; cursorNodeText?: string | undefined; }; interface Options { /** * Specify the line length that the printer will wrap on. * @default 80 */ printWidth: number; /** * Specify the number of spaces per indentation-level. * @default 2 */ tabWidth: number; /** * Indent lines with tabs instead of spaces * @default false */ useTabs: boolean; parentParser?: string | undefined; __embeddedInHtml?: boolean | undefined; } } namespace utils { function cleanDoc(doc: Doc): Doc; function findInDoc<T = Doc>(doc: Doc, callback: (doc: Doc) => T, defaultValue: T): T; function getDocParts(doc: Doc): Doc; function isConcat(doc: Doc): boolean; function isEmpty(doc: Doc): boolean; function isLineNext(doc: Doc): boolean; function mapDoc<T = Doc>(doc: Doc, callback: (doc: Doc) => T): T; function normalizeDoc(doc: Doc): Doc; function normalizeParts(parts: Doc[]): Doc[]; function propagateBreaks(doc: Doc): void; function removeLines(doc: Doc): Doc; function replaceNewlinesWithLiterallines(doc: Doc): Doc; function stripTrailingHardline(doc: Doc): Doc; function traverseDoc( doc: Doc, onEnter?: (doc: Doc) => void | boolean, onExit?: (doc: Doc) => void, shouldTraverseConditionalGroups?: boolean, ): void; function willBreak(doc: Doc): boolean; } }