@baic/yolk-cli 2.1.0-alpha.9 → 2.1.0-github.0

package/compiled/prettier/index.d.ts

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