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

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

    vscodeLanguageIds?: string[] | undefined;

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

export interface BaseSupportOption<Type extends SupportOptionType> {

     * Usually you can use {@link CoreCategoryType}

     * When passing a type other than the ones listed below, the option is

     * treated as taking any string as argument, and `--option <${type}>` will

     * 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

export interface IntSupportOption extends BaseSupportOption<'int'> {

    range?: SupportOptionRange | undefined;

export interface IntArraySupportOption extends BaseSupportOption<'int'> {

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

export interface BooleanSupportOption extends BaseSupportOption<'boolean'> {

    oppositeDescription?: string | undefined;

export interface BooleanArraySupportOption extends BaseSupportOption<'boolean'> {

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

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

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

export interface PathSupportOption extends BaseSupportOption<'path'> {

export interface PathArraySupportOption extends BaseSupportOption<'path'> {

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

export interface SupportOptions extends Record<string, SupportOption> {}

    "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": "214ccbed8015c1d4d35d15fb40392bae4bb39e167c9e9ba57b82ebfaa9d0c70e",

    "typesPublisherContentHash": "682e24cbfe793cafe22038d115a4535244613a09d5cccbe205993da3c69d30e6",

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: Tue, 26 Jul 2022 23:02:23 GMT

 * Last updated: Thu, 04 Aug 2022 23:02:16 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).

		@@ -1,2 +0,2 @@
		// Type definitions for prettier 2.6
		// Type definitions for prettier 2.7
		// Project: https://prettier.io
		@@ -539,2 +539,3 @@ // https://github.com/prettier/prettier
		vscodeLanguageIds?: string[] \| undefined;
		interpreters?: string[] \| undefined;
		}
		@@ -541,0 +542,0 @@

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

		@@ -11,3 +11,3 @@ # Installation
		### Additional Details
		* Last updated: Tue, 26 Jul 2022 23:02:23 GMT
		* Last updated: Thu, 04 Aug 2022 23:02:16 GMT
		* Dependencies: none
		@@ -14,0 +14,0 @@ * Global values: `prettier`

Improved metrics