.config/coc/extensions/node_modules/coc-prettier/node_modules/table/node_modules/ajv/dist/types/json-schema.d.ts

   1 export declare type SomeJSONSchema = JSONSchemaType<Known, true>;
   2 export declare type PartialSchema<T> = Partial<JSONSchemaType<T, true>>;
   3 declare type JSONType<T extends string, _partial extends boolean> = _partial extends true ? T | undefined : T;
   4 interface NumberKeywords {
   5     minimum?: number;
   6     maximum?: number;
   7     exclusiveMinimum?: number;
   8     exclusiveMaximum?: number;
   9     multipleOf?: number;
  10     format?: string;
  11 }
  12 interface StringKeywords {
  13     minLength?: number;
  14     maxLength?: number;
  15     pattern?: string;
  16     format?: string;
  17 }
  18 export declare type JSONSchemaType<T, _partial extends boolean = false> = (((T extends number ? {
  19     type: JSONType<"number" | "integer", _partial>;
  20 } & NumberKeywords : T extends string ? {
  21     type: JSONType<"string", _partial>;
  22 } & StringKeywords : T extends boolean ? {
  23     type: "boolean";
  24 } : T extends [any, ...any[]] ? {
  25     type: JSONType<"array", _partial>;
  26     items: {
  27         readonly [K in keyof T]-?: JSONSchemaType<T[K]> & Nullable<T[K]>;
  28     } & {
  29         length: T["length"];
  30     };
  31     minItems: T["length"];
  32 } & ({
  33     maxItems: T["length"];
  34 } | {
  35     additionalItems: false;
  36 }) : T extends readonly any[] ? {
  37     type: JSONType<"array", _partial>;
  38     items: JSONSchemaType<T[0]>;
  39     contains?: PartialSchema<T[0]>;
  40     minItems?: number;
  41     maxItems?: number;
  42     minContains?: number;
  43     maxContains?: number;
  44     uniqueItems?: true;
  45     additionalItems?: never;
  46 } : T extends Record<string, any> ? {
  47     type: JSONType<"object", _partial>;
  48     required: _partial extends true ? Readonly<(keyof T)[]> : Readonly<RequiredMembers<T>[]>;
  49     additionalProperties?: boolean | JSONSchemaType<T[string]>;
  50     unevaluatedProperties?: boolean | JSONSchemaType<T[string]>;
  51     properties?: _partial extends true ? Partial<PropertiesSchema<T>> : PropertiesSchema<T>;
  52     patternProperties?: {
  53         [Pattern in string]?: JSONSchemaType<T[string]>;
  54     };
  55     propertyNames?: JSONSchemaType<string>;
  56     dependencies?: {
  57         [K in keyof T]?: Readonly<(keyof T)[]> | PartialSchema<T>;
  58     };
  59     dependentRequired?: {
  60         [K in keyof T]?: Readonly<(keyof T)[]>;
  61     };
  62     dependentSchemas?: {
  63         [K in keyof T]?: PartialSchema<T>;
  64     };
  65     minProperties?: number;
  66     maxProperties?: number;
  67 } : T extends null ? {
  68     nullable: true;
  69 } : never) & {
  70     allOf?: Readonly<PartialSchema<T>[]>;
  71     anyOf?: Readonly<PartialSchema<T>[]>;
  72     oneOf?: Readonly<PartialSchema<T>[]>;
  73     if?: PartialSchema<T>;
  74     then?: PartialSchema<T>;
  75     else?: PartialSchema<T>;
  76     not?: PartialSchema<T>;
  77 }) | {
  78     anyOf: readonly JSONSchemaType<T, _partial>[];
  79 } | {
  80     oneOf: readonly JSONSchemaType<T, _partial>[];
  81 } | ({
  82     type: (T extends number ? JSONType<"number" | "integer", _partial> : T extends string ? JSONType<"string", _partial> : T extends boolean ? JSONType<"boolean", _partial> : never)[];
  83 } & (T extends number ? NumberKeywords : T extends string ? StringKeywords : T extends boolean ? unknown : never))) & {
  84     [keyword: string]: any;
  85     $id?: string;
  86     $ref?: string;
  87     $defs?: {
  88         [Key in string]?: JSONSchemaType<Known, true>;
  89     };
  90     definitions?: {
  91         [Key in string]?: JSONSchemaType<Known, true>;
  92     };
  93 };
  94 declare type Known = KnownRecord | [Known, ...Known[]] | Known[] | number | string | boolean | null;
  95 interface KnownRecord extends Record<string, Known> {
  96 }
  97 export declare type PropertiesSchema<T> = {
  98     [K in keyof T]-?: (JSONSchemaType<T[K]> & Nullable<T[K]>) | {
  99         $ref: string;
 100     };
 101 };
 102 export declare type RequiredMembers<T> = {
 103     [K in keyof T]-?: undefined extends T[K] ? never : K;
 104 }[keyof T];
 105 declare type Nullable<T> = undefined extends T ? {
 106     nullable: true;
 107     const?: never;
 108     enum?: Readonly<(T | null)[]>;
 109     default?: T | null;
 110 } : {
 111     const?: T;
 112     enum?: Readonly<T[]>;
 113     default?: T;
 114 };
 115 export {};