• Version 2.3.0
  • Published
  • 40.2 kB
  • No dependencies
  • MIT license


npm i @types/prettier
yarn add @types/prettier
pnpm add @types/prettier


TypeScript definitions for prettier






Type Aliases



variable version

const version: string;
  • version field in package.json


function check

check: (source: string, options?: Options) => boolean;
  • 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.

function clearConfigCache

clearConfigCache: () => void;
  • 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.

function format

format: (source: string, options?: Options) => string;
  • format is used to format text using Prettier. [Options](https://prettier.io/docs/en/options.html) may be provided to override the defaults.

function formatWithCursor

formatWithCursor: (source: string, options: CursorOptions) => CursorResult;
  • 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.

function getFileInfo

getFileInfo: typeof getFileInfo;

    function getSupportInfo

    getSupportInfo: () => SupportInfo;
    • Returns an object representing the parsers, languages and file types Prettier supports for the current version.

    function resolveConfig

    resolveConfig: typeof resolveConfig;
    • 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.

    function resolveConfigFile

    resolveConfigFile: typeof resolveConfigFile;
    • 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.


    class AstPath

    class AstPath<T = any> {}


      constructor(value: {});

        property stack

        stack: T[];

          method call

          call: <U>(callback: (path: this) => U, ...names: PropertyKey[]) => U;

            method callParent

            callParent: <U>(callback: (path: this) => U, count?: number) => U;

              method each

              each: (
              callback: (path: this, index: number, value: any) => void,
              ...names: PropertyKey[]
              ) => void;

                method getName

                getName: () => PropertyKey | null;

                  method getNode

                  getNode: (count?: number) => T | null;

                    method getParentNode

                    getParentNode: (count?: number) => T | null;

                      method getValue

                      getValue: () => T;

                        method map

                        map: <U>(
                        callback: (path: this, index: number, value: any) => U,
                        ...names: PropertyKey[]
                        ) => U[];

                          method match

                          match: (
                          ...predicates: ((
                          node: any,
                          name: string | null,
                          number: number | null
                          ) => boolean)[]
                          ) => boolean;


                            interface BaseSupportOption

                            interface BaseSupportOption<Type extends SupportOptionType> {}

                              property category

                              category: string;

                                property deprecated

                                deprecated?: true | string;
                                • 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.

                                property description

                                description?: string;
                                • Description to be displayed in --help. If omitted, the option won't be shown at all in --help.

                                property name

                                readonly name?: string;

                                  property since

                                  since: string;

                                    property type

                                    type: Type;
                                    • 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.

                                    interface BooleanArraySupportOption

                                    interface BooleanArraySupportOption extends BaseSupportOption<'boolean'> {}

                                      property array

                                      array: true;

                                        property default

                                        default: Array<{ value: boolean[] }>;

                                          interface BooleanSupportOption

                                          interface BooleanSupportOption extends BaseSupportOption<'boolean'> {}

                                            property array

                                            array?: false;

                                              property default

                                              default: boolean;

                                                property description

                                                description: string;

                                                  property oppositeDescription

                                                  oppositeDescription?: string;

                                                    interface ChoiceSupportOption

                                                    interface ChoiceSupportOption<Value = any> extends BaseSupportOption<'choice'> {}

                                                      property choices

                                                      choices: Array<{
                                                      since?: string;
                                                      value: Value;
                                                      description: string;

                                                        property default

                                                        default: Value | Array<{ since: string; value: Value }>;

                                                          property description

                                                          description: string;

                                                            interface CursorOptions

                                                            interface CursorOptions extends Options {}

                                                              property cursorOffset

                                                              cursorOffset: number;
                                                              • Specify where the cursor is.

                                                              property rangeEnd

                                                              rangeEnd?: never;

                                                                property rangeStart

                                                                rangeStart?: never;

                                                                  interface CursorResult

                                                                  interface CursorResult {}

                                                                    property cursorOffset

                                                                    cursorOffset: number;

                                                                      property formatted

                                                                      formatted: string;

                                                                        interface FileInfoOptions

                                                                        interface FileInfoOptions {}

                                                                          property ignorePath

                                                                          ignorePath?: string;

                                                                            property plugins

                                                                            plugins?: string[];

                                                                              property resolveConfig

                                                                              resolveConfig?: boolean;

                                                                                property withNodeModules

                                                                                withNodeModules?: boolean;

                                                                                  interface FileInfoResult

                                                                                  interface FileInfoResult {}

                                                                                    property ignored

                                                                                    ignored: boolean;

                                                                                      property inferredParser

                                                                                      inferredParser: string | null;

                                                                                        interface IntArraySupportOption

                                                                                        interface IntArraySupportOption extends BaseSupportOption<'int'> {}

                                                                                          property array

                                                                                          array: true;

                                                                                            property default

                                                                                            default: Array<{ value: number[] }>;

                                                                                              interface IntSupportOption

                                                                                              interface IntSupportOption extends BaseSupportOption<'int'> {}

                                                                                                property array

                                                                                                array?: false;

                                                                                                  property default

                                                                                                  default: number;

                                                                                                    property range

                                                                                                    range?: SupportOptionRange;

                                                                                                      interface Options

                                                                                                      interface Options extends Partial<RequiredOptions> {}

                                                                                                        interface Parser

                                                                                                        interface Parser<T = any> {}

                                                                                                          property astFormat

                                                                                                          astFormat: string;

                                                                                                            property hasPragma

                                                                                                            hasPragma?: (text: string) => boolean;

                                                                                                              property locEnd

                                                                                                              locEnd: (node: T) => number;

                                                                                                                property locStart

                                                                                                                locStart: (node: T) => number;

                                                                                                                  property parse

                                                                                                                  parse: (
                                                                                                                  text: string,
                                                                                                                  parsers: { [parserName: string]: Parser },
                                                                                                                  options: ParserOptions<T>
                                                                                                                  ) => T;

                                                                                                                    property preprocess

                                                                                                                    preprocess?: (text: string, options: ParserOptions<T>) => string;

                                                                                                                      interface ParserOptions

                                                                                                                      interface ParserOptions<T = any> extends RequiredOptions {}

                                                                                                                        property locEnd

                                                                                                                        locEnd: (node: T) => number;

                                                                                                                          property locStart

                                                                                                                          locStart: (node: T) => number;

                                                                                                                            property originalText

                                                                                                                            originalText: string;

                                                                                                                              interface PathArraySupportOption

                                                                                                                              interface PathArraySupportOption extends BaseSupportOption<'path'> {}

                                                                                                                                property array

                                                                                                                                array: true;

                                                                                                                                  property default

                                                                                                                                  default: Array<{ value: string[] }>;

                                                                                                                                    interface PathSupportOption

                                                                                                                                    interface PathSupportOption extends BaseSupportOption<'path'> {}

                                                                                                                                      property array

                                                                                                                                      array?: false;

                                                                                                                                        property default

                                                                                                                                        default: string;

                                                                                                                                          interface Plugin

                                                                                                                                          interface Plugin<T = any> {}

                                                                                                                                            property defaultOptions

                                                                                                                                            defaultOptions?: Partial<RequiredOptions>;

                                                                                                                                              property languages

                                                                                                                                              languages?: SupportLanguage[];

                                                                                                                                                property options

                                                                                                                                                options?: SupportOptions;

                                                                                                                                                  property parsers

                                                                                                                                                  parsers?: { [parserName: string]: Parser<T> };

                                                                                                                                                    property printers

                                                                                                                                                    printers?: { [astFormat: string]: Printer<T> };

                                                                                                                                                      interface Printer

                                                                                                                                                      interface Printer<T = any> {}

                                                                                                                                                        property canAttachComment

                                                                                                                                                        canAttachComment?: (node: T) => boolean;

                                                                                                                                                          property embed

                                                                                                                                                          embed?: (
                                                                                                                                                          path: AstPath<T>,
                                                                                                                                                          print: (path: AstPath<T>) => Doc,
                                                                                                                                                          textToDoc: (text: string, options: Options) => Doc,
                                                                                                                                                          options: ParserOptions<T>
                                                                                                                                                          ) => Doc | null;

                                                                                                                                                            property handleComments

                                                                                                                                                            handleComments?: {
                                                                                                                                                            ownLine?: (
                                                                                                                                                            commentNode: any,
                                                                                                                                                            text: string,
                                                                                                                                                            options: ParserOptions<T>,
                                                                                                                                                            ast: T,
                                                                                                                                                            isLastComment: boolean
                                                                                                                                                            ) => boolean;
                                                                                                                                                            endOfLine?: (
                                                                                                                                                            commentNode: any,
                                                                                                                                                            text: string,
                                                                                                                                                            options: ParserOptions<T>,
                                                                                                                                                            ast: T,
                                                                                                                                                            isLastComment: boolean
                                                                                                                                                            ) => boolean;
                                                                                                                                                            remaining?: (
                                                                                                                                                            commentNode: any,
                                                                                                                                                            text: string,
                                                                                                                                                            options: ParserOptions<T>,
                                                                                                                                                            ast: T,
                                                                                                                                                            isLastComment: boolean
                                                                                                                                                            ) => boolean;

                                                                                                                                                              property hasPrettierIgnore

                                                                                                                                                              hasPrettierIgnore?: (path: AstPath<T>) => boolean;

                                                                                                                                                                property insertPragma

                                                                                                                                                                insertPragma?: (text: string) => string;

                                                                                                                                                                  property massageAstNode

                                                                                                                                                                  massageAstNode?: (node: any, newNode: any, parent: any) => any;
                                                                                                                                                                  • Returns

                                                                                                                                                                    anything if you want to replace the node with it

                                                                                                                                                                  property printComment

                                                                                                                                                                  printComment?: (commentPath: AstPath<T>, options: ParserOptions<T>) => Doc;

                                                                                                                                                                    property willPrintOwnComments

                                                                                                                                                                    willPrintOwnComments?: (path: AstPath<T>) => boolean;

                                                                                                                                                                      method print

                                                                                                                                                                      print: (
                                                                                                                                                                      path: AstPath<T>,
                                                                                                                                                                      options: ParserOptions<T>,
                                                                                                                                                                      print: (path: AstPath<T>) => Doc
                                                                                                                                                                      ) => Doc;

                                                                                                                                                                        interface RequiredOptions

                                                                                                                                                                        interface RequiredOptions extends doc.printer.Options {}

                                                                                                                                                                          property arrowParens

                                                                                                                                                                          arrowParens: 'avoid' | 'always';
                                                                                                                                                                          • Include parentheses around a sole arrow function parameter. 'always'

                                                                                                                                                                          property bracketSpacing

                                                                                                                                                                          bracketSpacing: boolean;
                                                                                                                                                                          • Print spaces between brackets in object literals. true

                                                                                                                                                                          property embeddedLanguageFormatting

                                                                                                                                                                          embeddedLanguageFormatting: 'auto' | 'off';
                                                                                                                                                                          • Control whether Prettier formats quoted code embedded in the file. 'auto'

                                                                                                                                                                          property endOfLine

                                                                                                                                                                          endOfLine: 'auto' | 'lf' | 'crlf' | 'cr';
                                                                                                                                                                          • Which end of line characters to apply. 'lf'

                                                                                                                                                                          property filepath

                                                                                                                                                                          filepath: string;
                                                                                                                                                                          • Specify the input filepath. This will be used to do parser inference.

                                                                                                                                                                          property htmlWhitespaceSensitivity

                                                                                                                                                                          htmlWhitespaceSensitivity: 'css' | 'strict' | 'ignore';
                                                                                                                                                                          • How to handle whitespaces in HTML. 'css'

                                                                                                                                                                          property insertPragma

                                                                                                                                                                          insertPragma: boolean;
                                                                                                                                                                          • Prettier can insert a special 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 marker. false

                                                                                                                                                                          property jsxBracketSameLine

                                                                                                                                                                          jsxBracketSameLine: boolean;
                                                                                                                                                                          • Put the > of a multi-line JSX element at the end of the last line instead of being alone on the next line. false

                                                                                                                                                                          property jsxSingleQuote

                                                                                                                                                                          jsxSingleQuote: boolean;
                                                                                                                                                                          • Use single quotes in JSX. false

                                                                                                                                                                          property parser

                                                                                                                                                                          parser: LiteralUnion<BuiltInParserName> | CustomParser;
                                                                                                                                                                          • Specify which parser to use.

                                                                                                                                                                          property plugins

                                                                                                                                                                          plugins: Array<string | Plugin>;
                                                                                                                                                                          • The plugin API is in a beta state.

                                                                                                                                                                          property proseWrap

                                                                                                                                                                          proseWrap: 'always' | 'never' | 'preserve';
                                                                                                                                                                          • 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. 'preserve'

                                                                                                                                                                          property quoteProps

                                                                                                                                                                          quoteProps: 'as-needed' | 'consistent' | 'preserve';
                                                                                                                                                                          • Change when properties in objects are quoted. 'as-needed'

                                                                                                                                                                          property rangeEnd

                                                                                                                                                                          rangeEnd: number;
                                                                                                                                                                          • Format only a segment of a file. Infinity

                                                                                                                                                                          property rangeStart

                                                                                                                                                                          rangeStart: number;
                                                                                                                                                                          • Format only a segment of a file. 0

                                                                                                                                                                          property requirePragma

                                                                                                                                                                          requirePragma: boolean;
                                                                                                                                                                          • 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. false

                                                                                                                                                                          property semi

                                                                                                                                                                          semi: boolean;
                                                                                                                                                                          • Print semicolons at the ends of statements. true

                                                                                                                                                                          property singleQuote

                                                                                                                                                                          singleQuote: boolean;
                                                                                                                                                                          • Use single quotes instead of double quotes. false

                                                                                                                                                                          property trailingComma

                                                                                                                                                                          trailingComma: 'none' | 'es5' | 'all';
                                                                                                                                                                          • Print trailing commas wherever possible. 'es5'

                                                                                                                                                                          property vueIndentScriptAndStyle

                                                                                                                                                                          vueIndentScriptAndStyle: boolean;
                                                                                                                                                                          • Whether or not to indent the code inside and tags in Vue files. false

                                                                                                                                                                          interface ResolveConfigOptions

                                                                                                                                                                          interface ResolveConfigOptions {}

                                                                                                                                                                            property config

                                                                                                                                                                            config?: string;
                                                                                                                                                                            • Pass directly the path of the config file if you don't wish to search for it.

                                                                                                                                                                            property editorconfig

                                                                                                                                                                            editorconfig?: boolean;
                                                                                                                                                                            • 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

                                                                                                                                                                            property useCache

                                                                                                                                                                            useCache?: boolean;
                                                                                                                                                                            • If set to false, all caching will be bypassed.

                                                                                                                                                                            interface SupportInfo

                                                                                                                                                                            interface SupportInfo {}

                                                                                                                                                                              property languages

                                                                                                                                                                              languages: SupportLanguage[];

                                                                                                                                                                                property options

                                                                                                                                                                                options: SupportOption[];

                                                                                                                                                                                  interface SupportLanguage

                                                                                                                                                                                  interface SupportLanguage {}

                                                                                                                                                                                    property aceMode

                                                                                                                                                                                    aceMode?: string;

                                                                                                                                                                                      property aliases

                                                                                                                                                                                      aliases?: string[];

                                                                                                                                                                                        property codemirrorMimeType

                                                                                                                                                                                        codemirrorMimeType?: string;

                                                                                                                                                                                          property codemirrorMode

                                                                                                                                                                                          codemirrorMode?: string;

                                                                                                                                                                                            property extensions

                                                                                                                                                                                            extensions?: string[];

                                                                                                                                                                                              property filenames

                                                                                                                                                                                              filenames?: string[];

                                                                                                                                                                                                property group

                                                                                                                                                                                                group?: string;

                                                                                                                                                                                                  property linguistLanguageId

                                                                                                                                                                                                  linguistLanguageId?: number;

                                                                                                                                                                                                    property name

                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                      property parsers

                                                                                                                                                                                                      parsers: BuiltInParserName[] | string[];

                                                                                                                                                                                                        property since

                                                                                                                                                                                                        since?: string;

                                                                                                                                                                                                          property tmScope

                                                                                                                                                                                                          tmScope?: string;

                                                                                                                                                                                                            property vscodeLanguageIds

                                                                                                                                                                                                            vscodeLanguageIds?: string[];

                                                                                                                                                                                                              interface SupportOptionRange

                                                                                                                                                                                                              interface SupportOptionRange {}

                                                                                                                                                                                                                property end

                                                                                                                                                                                                                end: number;

                                                                                                                                                                                                                  property start

                                                                                                                                                                                                                  start: number;

                                                                                                                                                                                                                    property step

                                                                                                                                                                                                                    step: number;

                                                                                                                                                                                                                      interface SupportOptions

                                                                                                                                                                                                                      interface SupportOptions extends Record<string, SupportOption> {}

                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                        type AST

                                                                                                                                                                                                                        type AST = any;

                                                                                                                                                                                                                          type BuiltInParser

                                                                                                                                                                                                                          type BuiltInParser = (text: string, options?: any) => AST;

                                                                                                                                                                                                                            type BuiltInParserName

                                                                                                                                                                                                                            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';

                                                                                                                                                                                                                              type BuiltInParsers

                                                                                                                                                                                                                              type BuiltInParsers = Record<BuiltInParserName, BuiltInParser>;

                                                                                                                                                                                                                                type CustomParser

                                                                                                                                                                                                                                type CustomParser = (text: string, parsers: BuiltInParsers, options: Options) => AST;

                                                                                                                                                                                                                                  type Doc

                                                                                                                                                                                                                                  type Doc = doc.builders.Doc;

                                                                                                                                                                                                                                    type FastPath

                                                                                                                                                                                                                                    type FastPath<T = any> = AstPath<T>;
                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                      FastPath was renamed to AstPath

                                                                                                                                                                                                                                    type LiteralUnion

                                                                                                                                                                                                                                    type LiteralUnion<T extends U, U = string> = T | (Pick<U, never> & { _?: never });

                                                                                                                                                                                                                                      type SupportOption

                                                                                                                                                                                                                                      type SupportOption =
                                                                                                                                                                                                                                      | IntSupportOption
                                                                                                                                                                                                                                      | IntArraySupportOption
                                                                                                                                                                                                                                      | BooleanSupportOption
                                                                                                                                                                                                                                      | BooleanArraySupportOption
                                                                                                                                                                                                                                      | ChoiceSupportOption
                                                                                                                                                                                                                                      | PathSupportOption
                                                                                                                                                                                                                                      | PathArraySupportOption;

                                                                                                                                                                                                                                        type SupportOptionType

                                                                                                                                                                                                                                        type SupportOptionType = 'int' | 'boolean' | 'choice' | 'path';


                                                                                                                                                                                                                                          namespace doc

                                                                                                                                                                                                                                          namespace doc {}

                                                                                                                                                                                                                                            namespace doc.builders

                                                                                                                                                                                                                                            namespace doc.builders {}

                                                                                                                                                                                                                                              variable breakParent

                                                                                                                                                                                                                                              const breakParent: BreakParent;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [breakParent](https://github.com/prettier/prettier/blob/main/commands.md#breakparent)

                                                                                                                                                                                                                                              variable cursor

                                                                                                                                                                                                                                              const cursor: Cursor;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [cursor](https://github.com/prettier/prettier/blob/main/commands.md#cursor)

                                                                                                                                                                                                                                              variable hardline

                                                                                                                                                                                                                                              const hardline: Concat;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [hardline](https://github.com/prettier/prettier/blob/main/commands.md#hardline)

                                                                                                                                                                                                                                              variable hardlineWithoutBreakParent

                                                                                                                                                                                                                                              const hardlineWithoutBreakParent: HardlineWithoutBreakParent;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [hardlineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent)

                                                                                                                                                                                                                                              variable line

                                                                                                                                                                                                                                              const line: Line;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [line](https://github.com/prettier/prettier/blob/main/commands.md#line)

                                                                                                                                                                                                                                              variable lineSuffixBoundary

                                                                                                                                                                                                                                              const lineSuffixBoundary: LineSuffixBoundary;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [lineSuffixBoundary](https://github.com/prettier/prettier/blob/main/commands.md#linesuffixboundary)

                                                                                                                                                                                                                                              variable literalline

                                                                                                                                                                                                                                              const literalline: Concat;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [literalline](https://github.com/prettier/prettier/blob/main/commands.md#literalline)

                                                                                                                                                                                                                                              variable literallineWithoutBreakParent

                                                                                                                                                                                                                                              const literallineWithoutBreakParent: LiterallineWithoutBreakParent;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [literallineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent)

                                                                                                                                                                                                                                              variable softline

                                                                                                                                                                                                                                              const softline: Softline;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [softline](https://github.com/prettier/prettier/blob/main/commands.md#softline)

                                                                                                                                                                                                                                              variable trim

                                                                                                                                                                                                                                              const trim: Trim;
                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                • [trim](https://github.com/prettier/prettier/blob/main/commands.md#trim)

                                                                                                                                                                                                                                              function addAlignmentToDoc

                                                                                                                                                                                                                                              addAlignmentToDoc: (doc: Doc, size: number, tabWidth: number) => Doc;

                                                                                                                                                                                                                                                function align

                                                                                                                                                                                                                                                align: (widthOrString: Align['n'], doc: Doc) => Align;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [align](https://github.com/prettier/prettier/blob/main/commands.md#align)

                                                                                                                                                                                                                                                function concat

                                                                                                                                                                                                                                                concat: (docs: Doc[]) => Concat;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [concat](https://github.com/prettier/prettier/blob/main/commands.md#deprecated-concat)


                                                                                                                                                                                                                                                  use Doc[] instead

                                                                                                                                                                                                                                                function conditionalGroup

                                                                                                                                                                                                                                                conditionalGroup: (alternatives: Doc[], options?: GroupOptions) => Group;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [conditionalGroup](https://github.com/prettier/prettier/blob/main/commands.md#conditionalgroup)

                                                                                                                                                                                                                                                function dedent

                                                                                                                                                                                                                                                dedent: (doc: Doc) => Align;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [dedent](https://github.com/prettier/prettier/blob/main/commands.md#dedent)

                                                                                                                                                                                                                                                function dedentToRoot

                                                                                                                                                                                                                                                dedentToRoot: (doc: Doc) => Align;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [dedentToRoot](https://github.com/prettier/prettier/blob/main/commands.md#dedenttoroot)

                                                                                                                                                                                                                                                function fill

                                                                                                                                                                                                                                                fill: (docs: Doc[]) => Fill;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [fill](https://github.com/prettier/prettier/blob/main/commands.md#fill)

                                                                                                                                                                                                                                                function group

                                                                                                                                                                                                                                                group: (doc: Doc, opts?: GroupOptions) => Group;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [group](https://github.com/prettier/prettier/blob/main/commands.md#group)

                                                                                                                                                                                                                                                function ifBreak

                                                                                                                                                                                                                                                ifBreak: (
                                                                                                                                                                                                                                                ifBreak: Doc,
                                                                                                                                                                                                                                                noBreak?: Doc,
                                                                                                                                                                                                                                                options?: { groupId?: symbol }
                                                                                                                                                                                                                                                ) => IfBreak;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [ifBreak](https://github.com/prettier/prettier/blob/main/commands.md#ifbreak)

                                                                                                                                                                                                                                                function indent

                                                                                                                                                                                                                                                indent: (doc: Doc) => Indent;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [indent](https://github.com/prettier/prettier/blob/main/commands.md#indent)

                                                                                                                                                                                                                                                function indentIfBreak

                                                                                                                                                                                                                                                indentIfBreak: (
                                                                                                                                                                                                                                                doc: Doc,
                                                                                                                                                                                                                                                opts: { groupId: symbol; negate?: boolean }
                                                                                                                                                                                                                                                ) => IndentIfBreak;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [indentIfBreak](https://github.com/prettier/prettier/blob/main/commands.md#indentifbreak)

                                                                                                                                                                                                                                                function join

                                                                                                                                                                                                                                                join: (sep: Doc, docs: Doc[]) => Concat;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [join](https://github.com/prettier/prettier/blob/main/commands.md#join)

                                                                                                                                                                                                                                                function label

                                                                                                                                                                                                                                                label: (label: string, doc: Doc) => Label;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [label](https://github.com/prettier/prettier/blob/main/commands.md#label)

                                                                                                                                                                                                                                                function lineSuffix

                                                                                                                                                                                                                                                lineSuffix: (suffix: Doc) => LineSuffix;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [lineSuffix](https://github.com/prettier/prettier/blob/main/commands.md#linesuffix)

                                                                                                                                                                                                                                                function markAsRoot

                                                                                                                                                                                                                                                markAsRoot: (doc: Doc) => Align;
                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                  • [markAsRoot](https://github.com/prettier/prettier/blob/main/commands.md#markasroot)

                                                                                                                                                                                                                                                interface Align

                                                                                                                                                                                                                                                interface Align {}

                                                                                                                                                                                                                                                  property contents

                                                                                                                                                                                                                                                  contents: Doc;

                                                                                                                                                                                                                                                    property n

                                                                                                                                                                                                                                                    n: number | string | { type: 'root' };

                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                      type: 'align';

                                                                                                                                                                                                                                                        interface BreakParent

                                                                                                                                                                                                                                                        interface BreakParent {}

                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                          type: 'break-parent';

                                                                                                                                                                                                                                                            interface Concat

                                                                                                                                                                                                                                                            interface Concat {}

                                                                                                                                                                                                                                                              property parts

                                                                                                                                                                                                                                                              parts: Doc[];

                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                type: 'concat';

                                                                                                                                                                                                                                                                  interface Cursor

                                                                                                                                                                                                                                                                  interface Cursor {}

                                                                                                                                                                                                                                                                    property placeholder

                                                                                                                                                                                                                                                                    placeholder: symbol;

                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                      type: 'cursor';

                                                                                                                                                                                                                                                                        interface Fill

                                                                                                                                                                                                                                                                        interface Fill {}

                                                                                                                                                                                                                                                                          property parts

                                                                                                                                                                                                                                                                          parts: Doc[];

                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                            type: 'fill';

                                                                                                                                                                                                                                                                              interface Group

                                                                                                                                                                                                                                                                              interface Group {}

                                                                                                                                                                                                                                                                                property break

                                                                                                                                                                                                                                                                                break: boolean;

                                                                                                                                                                                                                                                                                  property contents

                                                                                                                                                                                                                                                                                  contents: Doc;

                                                                                                                                                                                                                                                                                    property expandedStates

                                                                                                                                                                                                                                                                                    expandedStates: Doc[];

                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                      type: 'group';

                                                                                                                                                                                                                                                                                        interface GroupOptions

                                                                                                                                                                                                                                                                                        interface GroupOptions {}

                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                          id?: symbol;

                                                                                                                                                                                                                                                                                            property shouldBreak

                                                                                                                                                                                                                                                                                            shouldBreak?: boolean;

                                                                                                                                                                                                                                                                                              interface HardlineWithoutBreakParent

                                                                                                                                                                                                                                                                                              interface HardlineWithoutBreakParent extends Line {}

                                                                                                                                                                                                                                                                                                property hard

                                                                                                                                                                                                                                                                                                hard: true;

                                                                                                                                                                                                                                                                                                  interface IfBreak

                                                                                                                                                                                                                                                                                                  interface IfBreak {}

                                                                                                                                                                                                                                                                                                    property breakContents

                                                                                                                                                                                                                                                                                                    breakContents: Doc;

                                                                                                                                                                                                                                                                                                      property flatContents

                                                                                                                                                                                                                                                                                                      flatContents: Doc;

                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                        type: 'if-break';

                                                                                                                                                                                                                                                                                                          interface Indent

                                                                                                                                                                                                                                                                                                          interface Indent {}

                                                                                                                                                                                                                                                                                                            property contents

                                                                                                                                                                                                                                                                                                            contents: Doc;

                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                              type: 'indent';

                                                                                                                                                                                                                                                                                                                interface IndentIfBreak

                                                                                                                                                                                                                                                                                                                interface IndentIfBreak {}

                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                  type: 'indent-if-break';

                                                                                                                                                                                                                                                                                                                    interface Label

                                                                                                                                                                                                                                                                                                                    interface Label {}

                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                      type: 'label';

                                                                                                                                                                                                                                                                                                                        interface Line

                                                                                                                                                                                                                                                                                                                        interface Line {}

                                                                                                                                                                                                                                                                                                                          property hard

                                                                                                                                                                                                                                                                                                                          hard?: boolean;

                                                                                                                                                                                                                                                                                                                            property literal

                                                                                                                                                                                                                                                                                                                            literal?: boolean;

                                                                                                                                                                                                                                                                                                                              property soft

                                                                                                                                                                                                                                                                                                                              soft?: boolean;

                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                type: 'line';

                                                                                                                                                                                                                                                                                                                                  interface LineSuffix

                                                                                                                                                                                                                                                                                                                                  interface LineSuffix {}

                                                                                                                                                                                                                                                                                                                                    property contents

                                                                                                                                                                                                                                                                                                                                    contents: Doc;

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type: 'line-suffix';

                                                                                                                                                                                                                                                                                                                                        interface LineSuffixBoundary

                                                                                                                                                                                                                                                                                                                                        interface LineSuffixBoundary {}

                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                          type: 'line-suffix-boundary';

                                                                                                                                                                                                                                                                                                                                            interface LiterallineWithoutBreakParent

                                                                                                                                                                                                                                                                                                                                            interface LiterallineWithoutBreakParent extends Line {}

                                                                                                                                                                                                                                                                                                                                              property hard

                                                                                                                                                                                                                                                                                                                                              hard: true;

                                                                                                                                                                                                                                                                                                                                                property literal

                                                                                                                                                                                                                                                                                                                                                literal: true;

                                                                                                                                                                                                                                                                                                                                                  interface Softline

                                                                                                                                                                                                                                                                                                                                                  interface Softline extends Line {}

                                                                                                                                                                                                                                                                                                                                                    property soft

                                                                                                                                                                                                                                                                                                                                                    soft: true;

                                                                                                                                                                                                                                                                                                                                                      interface Trim

                                                                                                                                                                                                                                                                                                                                                      interface Trim {}

                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                        type: 'trim';

                                                                                                                                                                                                                                                                                                                                                          type Doc

                                                                                                                                                                                                                                                                                                                                                          type Doc = string | Doc[] | DocCommand;

                                                                                                                                                                                                                                                                                                                                                            type DocCommand

                                                                                                                                                                                                                                                                                                                                                            type DocCommand =
                                                                                                                                                                                                                                                                                                                                                            | Align
                                                                                                                                                                                                                                                                                                                                                            | BreakParent
                                                                                                                                                                                                                                                                                                                                                            | Concat
                                                                                                                                                                                                                                                                                                                                                            | Cursor
                                                                                                                                                                                                                                                                                                                                                            | Fill
                                                                                                                                                                                                                                                                                                                                                            | Group
                                                                                                                                                                                                                                                                                                                                                            | IfBreak
                                                                                                                                                                                                                                                                                                                                                            | Indent
                                                                                                                                                                                                                                                                                                                                                            | IndentIfBreak
                                                                                                                                                                                                                                                                                                                                                            | Label
                                                                                                                                                                                                                                                                                                                                                            | Line
                                                                                                                                                                                                                                                                                                                                                            | LineSuffix
                                                                                                                                                                                                                                                                                                                                                            | LineSuffixBoundary
                                                                                                                                                                                                                                                                                                                                                            | Trim;

                                                                                                                                                                                                                                                                                                                                                              namespace doc.debug

                                                                                                                                                                                                                                                                                                                                                              namespace doc.debug {}

                                                                                                                                                                                                                                                                                                                                                                function printDocToDebug

                                                                                                                                                                                                                                                                                                                                                                printDocToDebug: (doc: Doc) => string;

                                                                                                                                                                                                                                                                                                                                                                  namespace doc.printer

                                                                                                                                                                                                                                                                                                                                                                  namespace doc.printer {}

                                                                                                                                                                                                                                                                                                                                                                    function printDocToString

                                                                                                                                                                                                                                                                                                                                                                    printDocToString: (
                                                                                                                                                                                                                                                                                                                                                                    doc: Doc,
                                                                                                                                                                                                                                                                                                                                                                    options: Options
                                                                                                                                                                                                                                                                                                                                                                    ) => { formatted: string; cursorNodeStart?: number; cursorNodeText?: string };

                                                                                                                                                                                                                                                                                                                                                                      interface Options

                                                                                                                                                                                                                                                                                                                                                                      interface Options {}

                                                                                                                                                                                                                                                                                                                                                                        property parentParser

                                                                                                                                                                                                                                                                                                                                                                        parentParser?: string;

                                                                                                                                                                                                                                                                                                                                                                          property printWidth

                                                                                                                                                                                                                                                                                                                                                                          printWidth: number;
                                                                                                                                                                                                                                                                                                                                                                          • Specify the line length that the printer will wrap on. 80

                                                                                                                                                                                                                                                                                                                                                                          property tabWidth

                                                                                                                                                                                                                                                                                                                                                                          tabWidth: number;
                                                                                                                                                                                                                                                                                                                                                                          • Specify the number of spaces per indentation-level. 2

                                                                                                                                                                                                                                                                                                                                                                          property useTabs

                                                                                                                                                                                                                                                                                                                                                                          useTabs: boolean;
                                                                                                                                                                                                                                                                                                                                                                          • Indent lines with tabs instead of spaces false

                                                                                                                                                                                                                                                                                                                                                                          namespace doc.utils

                                                                                                                                                                                                                                                                                                                                                                          namespace doc.utils {}

                                                                                                                                                                                                                                                                                                                                                                            function cleanDoc

                                                                                                                                                                                                                                                                                                                                                                            cleanDoc: (doc: Doc) => Doc;

                                                                                                                                                                                                                                                                                                                                                                              function findInDoc

                                                                                                                                                                                                                                                                                                                                                                              findInDoc: <T = builders.Doc>(
                                                                                                                                                                                                                                                                                                                                                                              doc: Doc,
                                                                                                                                                                                                                                                                                                                                                                              callback: (doc: Doc) => T,
                                                                                                                                                                                                                                                                                                                                                                              defaultValue: T
                                                                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                                                                function getDocParts

                                                                                                                                                                                                                                                                                                                                                                                getDocParts: (doc: Doc) => Doc;

                                                                                                                                                                                                                                                                                                                                                                                  function isConcat

                                                                                                                                                                                                                                                                                                                                                                                  isConcat: (doc: Doc) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                    function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                    isEmpty: (doc: Doc) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                      function isLineNext

                                                                                                                                                                                                                                                                                                                                                                                      isLineNext: (doc: Doc) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                        function mapDoc

                                                                                                                                                                                                                                                                                                                                                                                        mapDoc: <T = builders.Doc>(doc: Doc, callback: (doc: Doc) => T) => T;

                                                                                                                                                                                                                                                                                                                                                                                          function normalizeDoc

                                                                                                                                                                                                                                                                                                                                                                                          normalizeDoc: (doc: Doc) => Doc;

                                                                                                                                                                                                                                                                                                                                                                                            function normalizeParts

                                                                                                                                                                                                                                                                                                                                                                                            normalizeParts: (parts: Doc[]) => Doc[];

                                                                                                                                                                                                                                                                                                                                                                                              function propagateBreaks

                                                                                                                                                                                                                                                                                                                                                                                              propagateBreaks: (doc: Doc) => void;

                                                                                                                                                                                                                                                                                                                                                                                                function removeLines

                                                                                                                                                                                                                                                                                                                                                                                                removeLines: (doc: Doc) => Doc;

                                                                                                                                                                                                                                                                                                                                                                                                  function replaceNewlinesWithLiterallines

                                                                                                                                                                                                                                                                                                                                                                                                  replaceNewlinesWithLiterallines: (doc: Doc) => Doc;

                                                                                                                                                                                                                                                                                                                                                                                                    function stripTrailingHardline

                                                                                                                                                                                                                                                                                                                                                                                                    stripTrailingHardline: (doc: Doc) => Doc;

                                                                                                                                                                                                                                                                                                                                                                                                      function traverseDoc

                                                                                                                                                                                                                                                                                                                                                                                                      traverseDoc: (
                                                                                                                                                                                                                                                                                                                                                                                                      doc: Doc,
                                                                                                                                                                                                                                                                                                                                                                                                      onEnter?: (doc: Doc) => void | boolean,
                                                                                                                                                                                                                                                                                                                                                                                                      onExit?: (doc: Doc) => void,
                                                                                                                                                                                                                                                                                                                                                                                                      shouldTraverseConditionalGroups?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        function willBreak

                                                                                                                                                                                                                                                                                                                                                                                                        willBreak: (doc: Doc) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                          namespace getFileInfo

                                                                                                                                                                                                                                                                                                                                                                                                          namespace getFileInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                            function sync

                                                                                                                                                                                                                                                                                                                                                                                                            sync: (filePath: string, options?: FileInfoOptions) => FileInfoResult;

                                                                                                                                                                                                                                                                                                                                                                                                              namespace resolveConfig

                                                                                                                                                                                                                                                                                                                                                                                                              namespace resolveConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                function sync

                                                                                                                                                                                                                                                                                                                                                                                                                sync: (filePath: string, options?: ResolveConfigOptions) => Options | null;

                                                                                                                                                                                                                                                                                                                                                                                                                  namespace resolveConfigFile

                                                                                                                                                                                                                                                                                                                                                                                                                  namespace resolveConfigFile {}

                                                                                                                                                                                                                                                                                                                                                                                                                    function sync

                                                                                                                                                                                                                                                                                                                                                                                                                    sync: (filePath?: string) => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                      namespace util

                                                                                                                                                                                                                                                                                                                                                                                                                      namespace util {}

                                                                                                                                                                                                                                                                                                                                                                                                                        function addDanglingComment

                                                                                                                                                                                                                                                                                                                                                                                                                        addDanglingComment: (node: any, comment: any, marker: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          function addLeadingComment

                                                                                                                                                                                                                                                                                                                                                                                                                          addLeadingComment: (node: any, comment: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            function addTrailingComment

                                                                                                                                                                                                                                                                                                                                                                                                                            addTrailingComment: (node: any, comment: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              function getAlignmentSize

                                                                                                                                                                                                                                                                                                                                                                                                                              getAlignmentSize: (
                                                                                                                                                                                                                                                                                                                                                                                                                              value: string,
                                                                                                                                                                                                                                                                                                                                                                                                                              tabWidth: number,
                                                                                                                                                                                                                                                                                                                                                                                                                              startIndex?: number
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                function getIndentSize

                                                                                                                                                                                                                                                                                                                                                                                                                                getIndentSize: (value: string, tabWidth: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function getMaxContinuousCount

                                                                                                                                                                                                                                                                                                                                                                                                                                  getMaxContinuousCount: (str: string, target: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function getNextNonSpaceNonCommentCharacterIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                    getNextNonSpaceNonCommentCharacterIndex: <N>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                    node: N,
                                                                                                                                                                                                                                                                                                                                                                                                                                    locEnd: (node: N) => number
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function getStringWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                      getStringWidth: (text: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function hasNewline

                                                                                                                                                                                                                                                                                                                                                                                                                                        hasNewline: (text: string, index: number, opts?: SkipOptions) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function hasNewlineInRange

                                                                                                                                                                                                                                                                                                                                                                                                                                          hasNewlineInRange: (text: string, start: number, end: number) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function hasSpaces

                                                                                                                                                                                                                                                                                                                                                                                                                                            hasSpaces: (text: string, index: number, opts?: SkipOptions) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function isNextLineEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                              isNextLineEmpty: <N>(
                                                                                                                                                                                                                                                                                                                                                                                                                                              text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                              node: N,
                                                                                                                                                                                                                                                                                                                                                                                                                                              locEnd: (node: N) => number
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function isNextLineEmptyAfterIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                isNextLineEmptyAfterIndex: (text: string, index: number) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isPreviousLineEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                  isPreviousLineEmpty: <N>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                  text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: N,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  locStart: (node: N) => number
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function makeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                    makeString: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    rawContent: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    enclosingQuote: Quote,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    unescapeUnnecessaryEscapes?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                      skip: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      chars: string | RegExp
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => (text: string, index: number | false, opts?: SkipOptions) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function skipEverythingButNewLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                        skipEverythingButNewLine: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number | false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: SkipOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function skipInlineComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                          skipInlineComment: (text: string, index: number | false) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function skipNewline

                                                                                                                                                                                                                                                                                                                                                                                                                                                            skipNewline: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number | false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: SkipOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function skipSpaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                              skipSpaces: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number | false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: SkipOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function skipToLineEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                skipToLineEnd: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number | false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: SkipOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function skipTrailingComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skipTrailingComment: (text: string, index: number | false) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function skipWhitespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipWhitespace: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number | false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: SkipOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => number | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SkipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SkipOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property backwards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        backwards?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Quote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Quote = "'" | '"';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/prettier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@types/prettier"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>