Stub TypeScript definitions entry for prettier, which provides its own types definitions

types

@types/prettier

//          https://github.com/prettier/prettier

// Definitions by: Ika <https://github.com/ikatyang>

//                 Ifiok Jr. <https://github.com/ifiokjr>

//                 Florian Imdahl <https://github.com/ffflorian>

//                 Sosuke Suzuki <https://github.com/sosukesuzuki>

//                 Christopher Quadflieg <https://github.com/Shinigami92>

//                 Georgii Dolzhykov <https://github.com/thorn0>

//                 JounQin <https://github.com/JounQin>

//                 Chuah Chee Shian <https://github.com/shian15810>

// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

// Adding export {} here to shut off automatic exporting from index.d.ts. There

// are quite a few utility types here that don't need to be shipped with the

// This utility is here to handle the case where you have an explicit union

// between string literals and the generic string type. It would normally

// resolve out to just the string type, but this generic LiteralUnion maintains

// the intellisense of the original union.

// It comes from this issue: microsoft/TypeScript#29729:

//   https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227

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

// The type of elements that make up the given array T.

type ArrayElement<T> = T extends Array<infer E> ? E : never;

// A union of the properties of the given object that are arrays.

type ArrayProperties<T> = { [K in keyof T]: NonNullable<T[K]> extends any[] ? K : never }[keyof T];

// A union of the properties of the given array T that can be used to index it.

// If the array is a tuple, then that's going to be the explicit indices of the

// array, otherwise it's going to just be number.

type IndexProperties<T extends { length: number }> = IsTuple<T> extends true

    ? Exclude<Partial<T>['length'], T['length']>

// Effectively performing T[P], except that it's telling TypeScript that it's

// safe to do this for tuples, arrays, or objects.

type IndexValue<T, P> = T extends any[] ? (P extends number ? T[P] : never) : P extends keyof T ? T[P] : never;

// Determines if an object T is an array like string[] (in which case this

// evaluates to false) or a tuple like [string] (in which case this evaluates to

// eslint-disable-next-line @typescript-eslint/no-unused-vars

type IsTuple<T> = T extends [] ? true : T extends [infer First, ...infer Remain] ? IsTuple<Remain> : false;

type CallProperties<T> = T extends any[] ? IndexProperties<T> : keyof T;

type IterProperties<T> = T extends any[] ? IndexProperties<T> : ArrayProperties<T>;

type CallCallback<T, U> = (path: AstPath<T>, index: number, value: any) => U;

type EachCallback<T> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => void;

type MapCallback<T, U> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => U;

// https://github.com/prettier/prettier/blob/main/src/common/ast-path.js

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

    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>,

    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>,

        P2 extends CallProperties<T[P1]>,

        P3 extends CallProperties<IndexValue<T[P1], P2>>,

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

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

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

              textToDoc: (text: string, options: Options) => Doc,

    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;

                        commentNode: any,

                        options: ParserOptions<T>,

                        isLastComment: boolean,

export interface CursorOptions extends Options {

 * `format` is used to format text using Prettier. [Options](https://prettier.io/docs/en/options.html) may be provided to override the defaults.

export function format(source: string, options?: Options): string;

 * `check` checks to see if the file has been formatted with Prettier given those options and returns a `Boolean`.

 * This is similar to the `--list-different` parameter in the CLI and is useful for running Prettier in CI scenarios.

export function check(source: string, options?: Options): boolean;

 * `formatWithCursor` both formats the code, and translates a cursor position from unformatted code to formatted code.

 * This is useful for editor integrations, to prevent the cursor from moving when code is formatted.

 * The `cursorOffset` option should be provided, to specify where the cursor is. This option cannot be used with `rangeStart` and `rangeEnd`.

export function formatWithCursor(source: string, options: CursorOptions): CursorResult;

     * If set to `false`, all caching will be bypassed.

     * Pass directly the path of the config file if you don't wish to search for it.

     * 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:

    "description": "TypeScript definitions for prettier",

    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/prettier",

            "url": "https://github.com/ikatyang",

            "url": "https://github.com/ifiokjr",

            "url": "https://github.com/ffflorian",

            "githubUsername": "ffflorian"

            "url": "https://github.com/sosukesuzuki",

            "githubUsername": "sosukesuzuki"

            "name": "Christopher Quadflieg",

            "url": "https://github.com/Shinigami92",

            "githubUsername": "Shinigami92"

            "url": "https://github.com/thorn0",

            "url": "https://github.com/JounQin",

            "url": "https://github.com/shian15810",

            "githubUsername": "shian15810"

        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",

    "typesPublisherContentHash": "16eb6787683d9de1a2c255e5cee8bfd5ec6caf21540bed452a20668af03fe801",

    "typesPublisherContentHash": "214ccbed8015c1d4d35d15fb40392bae4bb39e167c9e9ba57b82ebfaa9d0c70e",

This package contains type definitions for prettier (https://prettier.io).

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/prettier.

 * Last updated: Sat, 28 May 2022 10:01:32 GMT

 * Last updated: Tue, 26 Jul 2022 23:02:23 GMT

These definitions were written by [Ika](https://github.com/ikatyang), [Ifiok Jr.](https://github.com/ifiokjr), [Florian Imdahl](https://github.com/ffflorian), [Sosuke Suzuki](https://github.com/sosukesuzuki), [Christopher Quadflieg](https://github.com/Shinigami92), [Georgii Dolzhykov](https://github.com/thorn0), [JounQin](https://github.com/JounQin), and [Chuah Chee Shian](https://github.com/shian15810).

		@@ -377,3 +377,3 @@ // Type definitions for prettier 2.6
		export interface Printer<T = any> {
		print(path: AstPath<T>, options: ParserOptions<T>, print: (path: AstPath<T>) => Doc): Doc;
		print(path: AstPath<T>, options: ParserOptions<T>, print: (path: AstPath<T>) => Doc, args?: unknown): Doc;
		embed?:
		@@ -380,0 +380,0 @@ \| ((

		{
		"name": "@types/prettier",
		"version": "2.6.3",
		"version": "2.6.4",
		"description": "TypeScript definitions for prettier",
		@@ -58,4 +58,4 @@ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/prettier",
		"dependencies": {},
		"typesPublisherContentHash": "16eb6787683d9de1a2c255e5cee8bfd5ec6caf21540bed452a20668af03fe801",
		"typesPublisherContentHash": "214ccbed8015c1d4d35d15fb40392bae4bb39e167c9e9ba57b82ebfaa9d0c70e",
		"typeScriptVersion": "4.2"
		}

		@@ -11,3 +11,3 @@ # Installation
		### Additional Details
		* Last updated: Sat, 28 May 2022 10:01:32 GMT
		* Last updated: Tue, 26 Jul 2022 23:02:23 GMT
		* Dependencies: none
		@@ -14,0 +14,0 @@ * Global values: `prettier`

Improved metrics