@alpic-ai/api 0.0.0-dev.gd9ebdf8 → 0.0.0-dev.gd9ec27f

package/dist/index.d.mts

@@ -29,6 +29,7 @@ export declare const runtimeSchema: z.ZodEnum<{
   "python3.14": "python3.14";
   node22: "node22";
   node24: "node24";
+  node26: "node26";
 }>;
 export declare const transportSchema: z.ZodEnum<{
   stdio: "stdio";
@@ -1383,6 +1384,19 @@ type ClaudeSubmission = z.infer<typeof claudeSubmissionSchemaInternal>;
 type ChatgptSubmission = z.infer<typeof chatgptSubmissionSchemaInternal>;
 type Submission = ClaudeSubmission | ChatgptSubmission;
 //#endregion
+//#region ../domains/src/telemetry/schemas.d.ts
+export declare const TELEMETRY_SIGNALS: readonly ["logs", "metrics", "traces"];
+export declare const telemetrySignalSchema: z.ZodEnum<{
+  logs: "logs";
+  metrics: "metrics";
+  traces: "traces";
+}>;
+export declare const OTLP_PROTOCOLS: readonly ["http/protobuf", "http/json"];
+export declare const otlpProtocolSchema: z.ZodEnum<{
+  "http/protobuf": "http/protobuf";
+  "http/json": "http/json";
+}>;
+//#endregion
 //#region src/api.contract.d.ts
 export type ApiContext = {
   request: Request & {
@@ -2675,6 +2689,206 @@ export declare const contract: {
       }>, Record<never, never>>;
     };
   };
+  telemetryDestinations: {
+    list: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+      }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>;
+        headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodNull;
+          isSecret: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodLiteral<false>;
+        }, z.core.$strip>], "isSecret">>;
+        status: z.ZodEnum<{
+          active: "active";
+          suspended: "suspended";
+        }>;
+        lastFailureReason: z.ZodNullable<z.ZodEnum<{
+          credentials: "credentials";
+          "wrong-path": "wrong-path";
+          "wrong-protocol": "wrong-protocol";
+          "invalid-payload": "invalid-payload";
+          "partial-rejection": "partial-rejection";
+          "blocked-target": "blocked-target";
+          timeout: "timeout";
+          unreachable: "unreachable";
+          "receiver-error": "receiver-error";
+          "unexpected-status": "unexpected-status";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodBoolean;
+      }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+      }>, Record<never, never>>;
+    };
+    create: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodDefault<z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodDefault<z.ZodBoolean>;
+        headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodBoolean;
+        }, z.core.$strip>>>;
+      }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>;
+        headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodNull;
+          isSecret: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodLiteral<false>;
+        }, z.core.$strip>], "isSecret">>;
+        status: z.ZodEnum<{
+          active: "active";
+          suspended: "suspended";
+        }>;
+        lastFailureReason: z.ZodNullable<z.ZodEnum<{
+          credentials: "credentials";
+          "wrong-path": "wrong-path";
+          "wrong-protocol": "wrong-protocol";
+          "invalid-payload": "invalid-payload";
+          "partial-rejection": "partial-rejection";
+          "blocked-target": "blocked-target";
+          timeout: "timeout";
+          unreachable: "unreachable";
+          "receiver-error": "receiver-error";
+          "unexpected-status": "unexpected-status";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodBoolean;
+      }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+        FORBIDDEN: {};
+        OTLP_DESTINATION_UNVERIFIED: {
+          status: number;
+        };
+        INTERNAL_SERVER_ERROR: {};
+      }>, Record<never, never>>;
+    };
+    update: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+        destinationId: z.ZodString;
+        endpoint: z.ZodOptional<z.ZodString>;
+        protocol: z.ZodOptional<z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          id: z.ZodOptional<z.ZodString>;
+          name: z.ZodString;
+          value: z.ZodOptional<z.ZodString>;
+          isSecret: z.ZodBoolean;
+        }, z.core.$strip>>>;
+      }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>;
+        headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodNull;
+          isSecret: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodLiteral<false>;
+        }, z.core.$strip>], "isSecret">>;
+        status: z.ZodEnum<{
+          active: "active";
+          suspended: "suspended";
+        }>;
+        lastFailureReason: z.ZodNullable<z.ZodEnum<{
+          credentials: "credentials";
+          "wrong-path": "wrong-path";
+          "wrong-protocol": "wrong-protocol";
+          "invalid-payload": "invalid-payload";
+          "partial-rejection": "partial-rejection";
+          "blocked-target": "blocked-target";
+          timeout: "timeout";
+          unreachable: "unreachable";
+          "receiver-error": "receiver-error";
+          "unexpected-status": "unexpected-status";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodBoolean;
+      }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+        FORBIDDEN: {};
+        OTLP_DESTINATION_UNVERIFIED: {
+          status: number;
+        };
+      }>, Record<never, never>>;
+    };
+    delete: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+        destinationId: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        success: z.ZodLiteral<true>;
+      }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+        INTERNAL_SERVER_ERROR: {};
+      }>, Record<never, never>>;
+    };
+  };
   projects: {
     update: {
       v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
@@ -2691,6 +2905,7 @@ export declare const contract: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -2769,6 +2984,7 @@ export declare const contract: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -2846,6 +3062,7 @@ export declare const contract: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -2921,6 +3138,7 @@ export declare const contract: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodOptional<z.ZodEnum<{
           stdio: "stdio";
@@ -2957,6 +3175,7 @@ export declare const contract: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -4553,6 +4772,206 @@ export declare const contractForDocs: {
       }>, Record<never, never>>;
     };
   };
+  telemetryDestinations: {
+    list: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+      }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>;
+        headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodNull;
+          isSecret: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodLiteral<false>;
+        }, z.core.$strip>], "isSecret">>;
+        status: z.ZodEnum<{
+          active: "active";
+          suspended: "suspended";
+        }>;
+        lastFailureReason: z.ZodNullable<z.ZodEnum<{
+          credentials: "credentials";
+          "wrong-path": "wrong-path";
+          "wrong-protocol": "wrong-protocol";
+          "invalid-payload": "invalid-payload";
+          "partial-rejection": "partial-rejection";
+          "blocked-target": "blocked-target";
+          timeout: "timeout";
+          unreachable: "unreachable";
+          "receiver-error": "receiver-error";
+          "unexpected-status": "unexpected-status";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodBoolean;
+      }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+      }>, Record<never, never>>;
+    };
+    create: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodDefault<z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodDefault<z.ZodBoolean>;
+        headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodBoolean;
+        }, z.core.$strip>>>;
+      }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>;
+        headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodNull;
+          isSecret: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodLiteral<false>;
+        }, z.core.$strip>], "isSecret">>;
+        status: z.ZodEnum<{
+          active: "active";
+          suspended: "suspended";
+        }>;
+        lastFailureReason: z.ZodNullable<z.ZodEnum<{
+          credentials: "credentials";
+          "wrong-path": "wrong-path";
+          "wrong-protocol": "wrong-protocol";
+          "invalid-payload": "invalid-payload";
+          "partial-rejection": "partial-rejection";
+          "blocked-target": "blocked-target";
+          timeout: "timeout";
+          unreachable: "unreachable";
+          "receiver-error": "receiver-error";
+          "unexpected-status": "unexpected-status";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodBoolean;
+      }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+        FORBIDDEN: {};
+        OTLP_DESTINATION_UNVERIFIED: {
+          status: number;
+        };
+        INTERNAL_SERVER_ERROR: {};
+      }>, Record<never, never>>;
+    };
+    update: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+        destinationId: z.ZodString;
+        endpoint: z.ZodOptional<z.ZodString>;
+        protocol: z.ZodOptional<z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          id: z.ZodOptional<z.ZodString>;
+          name: z.ZodString;
+          value: z.ZodOptional<z.ZodString>;
+          isSecret: z.ZodBoolean;
+        }, z.core.$strip>>>;
+      }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        signal: z.ZodEnum<{
+          logs: "logs";
+          metrics: "metrics";
+          traces: "traces";
+        }>;
+        endpoint: z.ZodString;
+        protocol: z.ZodEnum<{
+          "http/protobuf": "http/protobuf";
+          "http/json": "http/json";
+        }>;
+        headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodNull;
+          isSecret: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+          id: z.ZodString;
+          name: z.ZodString;
+          value: z.ZodString;
+          isSecret: z.ZodLiteral<false>;
+        }, z.core.$strip>], "isSecret">>;
+        status: z.ZodEnum<{
+          active: "active";
+          suspended: "suspended";
+        }>;
+        lastFailureReason: z.ZodNullable<z.ZodEnum<{
+          credentials: "credentials";
+          "wrong-path": "wrong-path";
+          "wrong-protocol": "wrong-protocol";
+          "invalid-payload": "invalid-payload";
+          "partial-rejection": "partial-rejection";
+          "blocked-target": "blocked-target";
+          timeout: "timeout";
+          unreachable: "unreachable";
+          "receiver-error": "receiver-error";
+          "unexpected-status": "unexpected-status";
+        }>>;
+        isScopedToIntentionalRequestsOnly: z.ZodBoolean;
+      }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+        FORBIDDEN: {};
+        OTLP_DESTINATION_UNVERIFIED: {
+          status: number;
+        };
+      }>, Record<never, never>>;
+    };
+    delete: {
+      v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        environmentId: z.ZodString;
+        destinationId: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        success: z.ZodLiteral<true>;
+      }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        BAD_REQUEST: {};
+      }>, {
+        NOT_FOUND: {};
+        INTERNAL_SERVER_ERROR: {};
+      }>, Record<never, never>>;
+    };
+  };
   projects: {
     update: {
       v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
@@ -4569,6 +4988,7 @@ export declare const contractForDocs: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -4647,6 +5067,7 @@ export declare const contractForDocs: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -4724,6 +5145,7 @@ export declare const contractForDocs: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -4799,6 +5221,7 @@ export declare const contractForDocs: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodOptional<z.ZodEnum<{
           stdio: "stdio";
@@ -4835,6 +5258,7 @@ export declare const contractForDocs: {
           "python3.14": "python3.14";
           node22: "node22";
           node24: "node24";
+          node26: "node26";
         }>;
         transport: z.ZodNullable<z.ZodEnum<{
           stdio: "stdio";
@@ -5842,7 +6266,7 @@ export type RouteAuthMeta = {
   authScope?: AuthScope;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/promisable.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/promisable.d.ts
 /**
 Create a type that represents either the value or the value wrapped in `PromiseLike`.
 
@@ -5869,11 +6293,11 @@ await logger(() => Promise.resolve('bar'));
 */
 type Promisable<T> = T | PromiseLike<T>;
 //#endregion
-//#region ../../node_modules/.pnpm/@orpc+shared@1.15.2_@opentelemetry+api@1.9.1/node_modules/@orpc/shared/dist/index.d.mts
+//#region ../../node_modules/.pnpm/@orpc+shared@1.15.7_@opentelemetry+api@1.9.1/node_modules/@orpc/shared/dist/index.d.mts
 type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions ? [options?: TOptions] : [options: TOptions];
 type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
 //#endregion
-//#region ../../node_modules/.pnpm/@orpc+client@1.15.2_@opentelemetry+api@1.9.1/node_modules/@orpc/client/dist/index.d.mts
+//#region ../../node_modules/.pnpm/@orpc+client@1.15.7_@opentelemetry+api@1.9.1/node_modules/@orpc/client/dist/index.d.mts
 declare const COMMON_ORPC_ERROR_DEFS: {
   readonly BAD_REQUEST: {
     readonly status: 400;
@@ -5986,7 +6410,7 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
 //#endregion
-//#region ../../node_modules/.pnpm/@orpc+server@1.15.2_@opentelemetry+api@1.9.1_ws@8.21.3/node_modules/@orpc/server/dist/shared/server.qKsRrdxW.d.mts
+//#region ../../node_modules/.pnpm/@orpc+server@1.15.7_@opentelemetry+api@1.9.1_ws@8.22.0/node_modules/@orpc/server/dist/shared/server.qKsRrdxW.d.mts
 type Context = Record<PropertyKey, any>;
 type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
 type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
@@ -6057,7 +6481,7 @@ interface Middleware<TInContext extends Context, TOutContext extends Context, TI
 }
 type AnyMiddleware = Middleware<any, any, any, any, any, any>;
 //#endregion
-//#region ../../node_modules/.pnpm/@orpc+server@1.15.2_@opentelemetry+api@1.9.1_ws@8.21.3/node_modules/@orpc/server/dist/shared/server.C8_sRzQB.d.mts
+//#region ../../node_modules/.pnpm/@orpc+server@1.15.7_@opentelemetry+api@1.9.1_ws@8.22.0/node_modules/@orpc/server/dist/shared/server.C8_sRzQB.d.mts
 interface TraverseContractProcedureCallbackOptions {
   contract: AnyContractProcedure | AnyProcedure;
   path: readonly string[];
@@ -6066,976 +6490,976 @@ interface TraverseContractProcedureCallbackOptions {
 //#region ../../node_modules/.pnpm/json-schema-typed@8.0.2/node_modules/json-schema-typed/draft_2020_12.d.ts
 type MaybeReadonlyArray<T> = Array<T> | ReadonlyArray<T>;
 type ValueOf<T> = T[keyof T];
-/**
- * JSON Schema [Draft 2020-12](https://json-schema.org/draft/2020-12/json-schema-validation.html)
+/**
+ * JSON Schema [Draft 2020-12](https://json-schema.org/draft/2020-12/json-schema-validation.html)
  */
 type JSONSchema<Value = any, SchemaType = Value extends boolean ? "boolean" : Value extends null ? "null" : Value extends number ? "number" | "integer" : Value extends string ? "string" : Value extends unknown[] ? "array" : Value extends Record<string | number, unknown> ? "object" : JSONSchema.TypeValue> = boolean | {
-  /**
-   * Using JSON Pointer fragments requires knowledge of the structure of the
-   * schema. When writing schema documents with the intention to provide
-   * re-usable schemas, it may be preferable to use a plain name fragment
-   * that is not tied to any particular structural location.  This allows a
-   * subschema to be relocated without requiring JSON Pointer references to
-   * be updated.
-   *
-   * The `$anchor` keyword is used to specify such a fragment.  It is an
-   * identifier keyword that can only be used to create plain name fragments.
-   *
-   * If present, the value of this keyword MUST be a string, which MUST start
-   * with a letter `[A-Za-z]`, followed by any number of letters, digits
-   * `[0-9]`, hyphens `-`, underscores `_`, colons `:`,
-   * or periods `.`.
-   *
-   * Note that the anchor string does not include the `#` character,
-   * as it is not a URI-reference.  An `{"$anchor": "foo"}` becomes the
-   * fragment `#foo` when used in a URI.
-   *
-   * The base URI to which the resulting fragment is appended is determined
-   * by the `$id` keyword as explained in the previous section.
-   * Two `$anchor` keywords in the same schema document MAY have the same
-   * value if they apply to different base URIs, as the resulting full URIs
-   * will be distinct.  However, the effect of two `$anchor` keywords
-   * with the same value and the same base URI is undefined.  Implementations
-   * MAY raise an error if such usage is detected.
+  /**
+   * Using JSON Pointer fragments requires knowledge of the structure of the
+   * schema. When writing schema documents with the intention to provide
+   * re-usable schemas, it may be preferable to use a plain name fragment
+   * that is not tied to any particular structural location.  This allows a
+   * subschema to be relocated without requiring JSON Pointer references to
+   * be updated.
+   *
+   * The `$anchor` keyword is used to specify such a fragment.  It is an
+   * identifier keyword that can only be used to create plain name fragments.
+   *
+   * If present, the value of this keyword MUST be a string, which MUST start
+   * with a letter `[A-Za-z]`, followed by any number of letters, digits
+   * `[0-9]`, hyphens `-`, underscores `_`, colons `:`,
+   * or periods `.`.
+   *
+   * Note that the anchor string does not include the `#` character,
+   * as it is not a URI-reference.  An `{"$anchor": "foo"}` becomes the
+   * fragment `#foo` when used in a URI.
+   *
+   * The base URI to which the resulting fragment is appended is determined
+   * by the `$id` keyword as explained in the previous section.
+   * Two `$anchor` keywords in the same schema document MAY have the same
+   * value if they apply to different base URIs, as the resulting full URIs
+   * will be distinct.  However, the effect of two `$anchor` keywords
+   * with the same value and the same base URI is undefined.  Implementations
+   * MAY raise an error if such usage is detected.
    */
   $anchor?: string;
-  /**
-   * This keyword reserves a location for comments from schema authors to
-   * readers or maintainers of the schema.
-   *
-   * The value of this keyword MUST be a string. Implementations MUST NOT
-   * present this string to end users.  Tools for editing schemas SHOULD
-   * support displaying and editing this keyword.  The value of this keyword
-   * MAY be used in debug or error output which is intended for developers
-   * making use of schemas.
-   *
-   * Schema vocabularies SHOULD allow `$comment` within any object
-   * containing vocabulary keywords.  Implementations MAY assume `$comment`
-   * is allowed unless the vocabulary specifically forbids it.  Vocabularies
-   * MUST NOT specify any effect of `$comment` beyond what is described in
-   * this specification.
-   *
-   * Tools that translate other media types or programming languages
-   * to and from `application/schema+json` MAY choose to convert that media
-   * type or programming language's native comments to or from `$comment`
-   * values. The behavior of such translation when both native comments and
-   * `$comment` properties are present is implementation-dependent.
-   *
-   * Implementations MAY strip `$comment` values at any point during
-   * processing. In particular, this allows for shortening schemas when the
-   * size of deployed schemas is a concern.
-   *
-   * Implementations MUST NOT take any other action based on the presence,
-   * absence, or contents of `$comment` properties.  In particular, the
-   * value of `$comment` MUST NOT be collected as an annotation result.
+  /**
+   * This keyword reserves a location for comments from schema authors to
+   * readers or maintainers of the schema.
+   *
+   * The value of this keyword MUST be a string. Implementations MUST NOT
+   * present this string to end users.  Tools for editing schemas SHOULD
+   * support displaying and editing this keyword.  The value of this keyword
+   * MAY be used in debug or error output which is intended for developers
+   * making use of schemas.
+   *
+   * Schema vocabularies SHOULD allow `$comment` within any object
+   * containing vocabulary keywords.  Implementations MAY assume `$comment`
+   * is allowed unless the vocabulary specifically forbids it.  Vocabularies
+   * MUST NOT specify any effect of `$comment` beyond what is described in
+   * this specification.
+   *
+   * Tools that translate other media types or programming languages
+   * to and from `application/schema+json` MAY choose to convert that media
+   * type or programming language's native comments to or from `$comment`
+   * values. The behavior of such translation when both native comments and
+   * `$comment` properties are present is implementation-dependent.
+   *
+   * Implementations MAY strip `$comment` values at any point during
+   * processing. In particular, this allows for shortening schemas when the
+   * size of deployed schemas is a concern.
+   *
+   * Implementations MUST NOT take any other action based on the presence,
+   * absence, or contents of `$comment` properties.  In particular, the
+   * value of `$comment` MUST NOT be collected as an annotation result.
    */
   $comment?: string;
-  /**
-   * The `$defs` keyword reserves a location for schema authors to inline
-   * re-usable JSON Schemas into a more general schema. The keyword does not
-   * directly affect the validation result.
-   *
-   * This keyword's value MUST be an object. Each member value of this object
-   * MUST be a valid JSON Schema.
+  /**
+   * The `$defs` keyword reserves a location for schema authors to inline
+   * re-usable JSON Schemas into a more general schema. The keyword does not
+   * directly affect the validation result.
+   *
+   * This keyword's value MUST be an object. Each member value of this object
+   * MUST be a valid JSON Schema.
    */
   $defs?: Record<string, JSONSchema>;
-  /**
-   * "The `$dynamicAnchor` indicates that the fragment is an extension
-   * point when used with the `$dynamicRef` keyword. This low-level,
-   * advanced feature makes it easier to extend recursive schemas such as the
-   * meta-schemas, without imposing any particular semantics on that
-   * extension. See `$dynamicRef` for more details.
+  /**
+   * "The `$dynamicAnchor` indicates that the fragment is an extension
+   * point when used with the `$dynamicRef` keyword. This low-level,
+   * advanced feature makes it easier to extend recursive schemas such as the
+   * meta-schemas, without imposing any particular semantics on that
+   * extension. See `$dynamicRef` for more details.
    */
   $dynamicAnchor?: string;
-  /**
-   * The `$dynamicRef` keyword is an applicator that allows for deferring
-   * the full resolution until runtime, at which point it is resolved each
-   * time it is encountered while evaluating an instance.
-   *
-   * Together with `$dynamicAnchor`, `$dynamicRef` implements a
-   * cooperative extension mechanism that is primarily useful with recursive
-   * schemas (schemas that reference themselves).  Both the extension point
-   * and the runtime-determined extension target are defined with
-   * `$dynamicAnchor`, and only exhibit runtime dynamic behavior when
-   * referenced with `$dynamicRef`.
-   *
-   * The value of the `$dynamicRef` property MUST be a string which is
-   * a URI-Reference.  Resolved against the current URI base, it produces
-   * the URI used as the starting point for runtime resolution.  This initial
-   * resolution is safe to perform on schema load.
-   *
-   * If the initially resolved starting point URI includes a fragment that
-   * was created by the `$dynamicAnchor` keyword, the initial URI MUST be
-   * replaced by the URI (including the fragment) for the outermost schema
-   * resource in the [dynamic scope][scopes] that defines
-   * an identically named fragment with `$dynamicAnchor`.
-   *
-   * Otherwise, its behavior is identical to `$ref`, and no runtime
-   * resolution is needed.
-   *
-   * [scopes]: https://json-schema.org/draft/2020-12/json-schema-core.html#scopes
-   *
-   * @format "uri-reference"
+  /**
+   * The `$dynamicRef` keyword is an applicator that allows for deferring
+   * the full resolution until runtime, at which point it is resolved each
+   * time it is encountered while evaluating an instance.
+   *
+   * Together with `$dynamicAnchor`, `$dynamicRef` implements a
+   * cooperative extension mechanism that is primarily useful with recursive
+   * schemas (schemas that reference themselves).  Both the extension point
+   * and the runtime-determined extension target are defined with
+   * `$dynamicAnchor`, and only exhibit runtime dynamic behavior when
+   * referenced with `$dynamicRef`.
+   *
+   * The value of the `$dynamicRef` property MUST be a string which is
+   * a URI-Reference.  Resolved against the current URI base, it produces
+   * the URI used as the starting point for runtime resolution.  This initial
+   * resolution is safe to perform on schema load.
+   *
+   * If the initially resolved starting point URI includes a fragment that
+   * was created by the `$dynamicAnchor` keyword, the initial URI MUST be
+   * replaced by the URI (including the fragment) for the outermost schema
+   * resource in the [dynamic scope][scopes] that defines
+   * an identically named fragment with `$dynamicAnchor`.
+   *
+   * Otherwise, its behavior is identical to `$ref`, and no runtime
+   * resolution is needed.
+   *
+   * [scopes]: https://json-schema.org/draft/2020-12/json-schema-core.html#scopes
+   *
+   * @format "uri-reference"
    */
   $dynamicRef?: string;
-  /**
-   * The `$id` keyword identifies a schema resource with its
-   * [canonical][[RFC6596]] URI.
-   *
-   * Note that this URI is an identifier and not necessarily a network
-   * locator. In the case of a network-addressable URL, a schema need not be
-   * downloadable from its canonical URI.
-   *
-   * If present, the value for this keyword MUST be a string, and MUST
-   * represent a valid [URI-reference][RFC3986].  This URI-reference SHOULD
-   * be normalized, and MUST resolve to an [absolute-URI][RFC3986] (without a
-   * fragment).  Therefore, `$id` MUST NOT contain a non-empty fragment,
-   * and SHOULD NOT contain an empty fragment.
-   *
-   * Since an empty fragment in the context of the
-   * `application/schema+json` media type refers to the same resource as
-   * the base URI without a fragment, an implementation MAY normalize a URI
-   * ending with an empty fragment by removing the fragment.  However, schema
-   * authors SHOULD NOT rely on this behavior across implementations.
-   *
-   * This URI also serves as the base URI for relative URI-references in
-   * keywords within the schema resource, in accordance with
-   * [RFC 3986][RFC3986] section 5.1.1 regarding base URIs embedded in
-   * content.
-   *
-   * The presence of `$id` in a subschema indicates that the subschema
-   * constitutes a distinct schema resource within a single schema document.
-   * Furthermore, in accordance with [RFC 3986][RFC3986] section 5.1.2
-   * regarding encapsulating entities, if an `$id` in a subschema is a
-   * relative URI-reference, the base URI for resolving that reference is the
-   * URI of the parent schema resource.
-   *
-   * If no parent schema object explicitly identifies itself as a resource
-   * with `$id`, the base URI is that of the entire document.
-   *
-   * The root schema of a JSON Schema document SHOULD contain an `$id`
-   * keyword with an [absolute-URI][RFC3986] (containing a scheme, but no
-   * fragment).
-   *
-   * [RFC6596]: https://datatracker.ietf.org/doc/html/rfc6596
-   * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
-   *
-   * @format "uri-reference"
+  /**
+   * The `$id` keyword identifies a schema resource with its
+   * [canonical][[RFC6596]] URI.
+   *
+   * Note that this URI is an identifier and not necessarily a network
+   * locator. In the case of a network-addressable URL, a schema need not be
+   * downloadable from its canonical URI.
+   *
+   * If present, the value for this keyword MUST be a string, and MUST
+   * represent a valid [URI-reference][RFC3986].  This URI-reference SHOULD
+   * be normalized, and MUST resolve to an [absolute-URI][RFC3986] (without a
+   * fragment).  Therefore, `$id` MUST NOT contain a non-empty fragment,
+   * and SHOULD NOT contain an empty fragment.
+   *
+   * Since an empty fragment in the context of the
+   * `application/schema+json` media type refers to the same resource as
+   * the base URI without a fragment, an implementation MAY normalize a URI
+   * ending with an empty fragment by removing the fragment.  However, schema
+   * authors SHOULD NOT rely on this behavior across implementations.
+   *
+   * This URI also serves as the base URI for relative URI-references in
+   * keywords within the schema resource, in accordance with
+   * [RFC 3986][RFC3986] section 5.1.1 regarding base URIs embedded in
+   * content.
+   *
+   * The presence of `$id` in a subschema indicates that the subschema
+   * constitutes a distinct schema resource within a single schema document.
+   * Furthermore, in accordance with [RFC 3986][RFC3986] section 5.1.2
+   * regarding encapsulating entities, if an `$id` in a subschema is a
+   * relative URI-reference, the base URI for resolving that reference is the
+   * URI of the parent schema resource.
+   *
+   * If no parent schema object explicitly identifies itself as a resource
+   * with `$id`, the base URI is that of the entire document.
+   *
+   * The root schema of a JSON Schema document SHOULD contain an `$id`
+   * keyword with an [absolute-URI][RFC3986] (containing a scheme, but no
+   * fragment).
+   *
+   * [RFC6596]: https://datatracker.ietf.org/doc/html/rfc6596
+   * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
+   *
+   * @format "uri-reference"
    */
   $id?: string;
-  /**
-   * The `$ref` keyword is an applicator that is used to reference a
-   * statically identified schema. Its results are the results of the
-   * referenced schema. Other keywords can appear alongside of `$ref` in
-   * the same schema object.
-   *
-   * The value of the `$ref` property MUST be a string which is a
-   * URI-Reference. Resolved against the current URI base, it produces the
-   * URI of the schema to apply.
-   *
-   * @format "uri-reference"
+  /**
+   * The `$ref` keyword is an applicator that is used to reference a
+   * statically identified schema. Its results are the results of the
+   * referenced schema. Other keywords can appear alongside of `$ref` in
+   * the same schema object.
+   *
+   * The value of the `$ref` property MUST be a string which is a
+   * URI-Reference. Resolved against the current URI base, it produces the
+   * URI of the schema to apply.
+   *
+   * @format "uri-reference"
    */
   $ref?: string;
-  /**
-   * The `$schema` keyword is both used as a JSON Schema dialect identifier
-   * and as the identifier of a resource which is itself a JSON Schema, which
-   * describes the set of valid schemas written for this particular dialect.
-   *
-   * The value of this keyword MUST be a [URI][RFC3986] (containing a scheme)
-   * and this URI MUST be normalized. The current schema MUST be valid
-   * against the meta-schema identified by this URI.
-   *
-   * If this URI identifies a retrievable resource, that resource SHOULD be
-   * of media type `application/schema+json`.
-   *
-   * The `$schema` keyword SHOULD be used in the document root schema
-   * object, and MAY be used in the root schema objects of embedded schema
-   * resources. It MUST NOT appear in non-resource root schema objects.  If
-   * absent from the document root schema, the resulting behavior is
-   * implementation-defined.
-   *
-   * Values for this property are defined elsewhere in this and other
-   * documents, and by other parties.
-   *
-   * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
-   *
-   * @format "uri"
+  /**
+   * The `$schema` keyword is both used as a JSON Schema dialect identifier
+   * and as the identifier of a resource which is itself a JSON Schema, which
+   * describes the set of valid schemas written for this particular dialect.
+   *
+   * The value of this keyword MUST be a [URI][RFC3986] (containing a scheme)
+   * and this URI MUST be normalized. The current schema MUST be valid
+   * against the meta-schema identified by this URI.
+   *
+   * If this URI identifies a retrievable resource, that resource SHOULD be
+   * of media type `application/schema+json`.
+   *
+   * The `$schema` keyword SHOULD be used in the document root schema
+   * object, and MAY be used in the root schema objects of embedded schema
+   * resources. It MUST NOT appear in non-resource root schema objects.  If
+   * absent from the document root schema, the resulting behavior is
+   * implementation-defined.
+   *
+   * Values for this property are defined elsewhere in this and other
+   * documents, and by other parties.
+   *
+   * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
+   *
+   * @format "uri"
    */
   $schema?: string;
-  /**
-   * The `$vocabulary` keyword is used in meta-schemas to identify the
-   * vocabularies available for use in schemas described by that meta-schema.
-   * It is also used to indicate whether each vocabulary is required or
-   * optional, in the sense that an implementation MUST understand the
-   * required vocabularies in order to successfully process the schema.
-   * Together, this information forms a dialect. Any vocabulary that is
-   * understood by the implementation MUST be processed in a manner
-   * consistent with the semantic definitions contained within the
-   * vocabulary.
-   *
-   * The value of this keyword MUST be an object.  The property names in the
-   * object MUST be URIs (containing a scheme) and this URI MUST be
-   * normalized. Each URI that appears as a property name identifies a
-   * specific set of keywords and their semantics.
-   *
-   * The URI MAY be a URL, but the nature of the retrievable resource is
-   * currently undefined, and reserved for future use.  Vocabulary authors
-   * MAY use the URL of the vocabulary specification, in a human-readable
-   * media type such as `text/html` or `text/plain`, as the vocabulary
-   * URI.
-   *
-   * The values of the object properties MUST be booleans. If the value is
-   * `true`, then implementations that do not recognize the vocabulary MUST
-   * refuse to process any schemas that declare this meta-schema with
-   * `$schema`.  If the value is `false`, implementations that do not
-   * recognize the vocabulary SHOULD proceed with processing such schemas.
-   * The value has no impact if the implementation understands the
-   * vocabulary.
-   *
-   * Unrecognized keywords SHOULD be ignored.  This remains the case for
-   * keywords defined by unrecognized vocabularies.  It is not currently
-   * possible to distinguish between unrecognized keywords that are defined
-   * in vocabularies from those that are not part of any vocabulary.
-   *
-   * The `$vocabulary` keyword SHOULD be used in the root schema of any
-   * schema document intended for use as a meta-schema.  It MUST NOT appear
-   * in subschemas.
-   *
-   * The `$vocabulary` keyword MUST be ignored in schema documents that are
-   * not being processed as a meta-schema.
+  /**
+   * The `$vocabulary` keyword is used in meta-schemas to identify the
+   * vocabularies available for use in schemas described by that meta-schema.
+   * It is also used to indicate whether each vocabulary is required or
+   * optional, in the sense that an implementation MUST understand the
+   * required vocabularies in order to successfully process the schema.
+   * Together, this information forms a dialect. Any vocabulary that is
+   * understood by the implementation MUST be processed in a manner
+   * consistent with the semantic definitions contained within the
+   * vocabulary.
+   *
+   * The value of this keyword MUST be an object.  The property names in the
+   * object MUST be URIs (containing a scheme) and this URI MUST be
+   * normalized. Each URI that appears as a property name identifies a
+   * specific set of keywords and their semantics.
+   *
+   * The URI MAY be a URL, but the nature of the retrievable resource is
+   * currently undefined, and reserved for future use.  Vocabulary authors
+   * MAY use the URL of the vocabulary specification, in a human-readable
+   * media type such as `text/html` or `text/plain`, as the vocabulary
+   * URI.
+   *
+   * The values of the object properties MUST be booleans. If the value is
+   * `true`, then implementations that do not recognize the vocabulary MUST
+   * refuse to process any schemas that declare this meta-schema with
+   * `$schema`.  If the value is `false`, implementations that do not
+   * recognize the vocabulary SHOULD proceed with processing such schemas.
+   * The value has no impact if the implementation understands the
+   * vocabulary.
+   *
+   * Unrecognized keywords SHOULD be ignored.  This remains the case for
+   * keywords defined by unrecognized vocabularies.  It is not currently
+   * possible to distinguish between unrecognized keywords that are defined
+   * in vocabularies from those that are not part of any vocabulary.
+   *
+   * The `$vocabulary` keyword SHOULD be used in the root schema of any
+   * schema document intended for use as a meta-schema.  It MUST NOT appear
+   * in subschemas.
+   *
+   * The `$vocabulary` keyword MUST be ignored in schema documents that are
+   * not being processed as a meta-schema.
    */
   $vocabulary?: Record<string, string>;
-  /**
-   * @deprecated `additionalItems` has been deprecated in favor of `prefixItems`
-   * paired with `items`.
+  /**
+   * @deprecated `additionalItems` has been deprecated in favor of `prefixItems`
+   * paired with `items`.
    */
   additionalItems?: JSONSchema;
-  /**
-   * The value of `additionalProperties` MUST be a valid JSON Schema.
-   *
-   * The behavior of this keyword depends on the presence and annotation
-   * results of `properties` and `patternProperties` within the same
-   * schema object. Validation with `additionalProperties` applies only to
-   * the child values of instance names that do not appear in the annotation
-   * results of either `properties` or `patternProperties`.
-   *
-   * For all such properties, validation succeeds if the child instance
-   * validates against the `additionalProperties` schema.
-   *
-   * The annotation result of this keyword is the set of instance property
-   * names validated by this keyword's subschema. Annotation results for
-   * `additionalProperties` keywords from multiple schemas applied to the
-   * same instance location are combined by taking the union of the sets.
-   *
-   * Omitting this keyword has the same assertion behavior as an empty
-   * schema.
-   *
-   * Implementations MAY choose to implement or optimize this keyword in
-   * another way that produces the same effect, such as by directly checking
-   * the names in `properties` and the patterns in `patternProperties`
-   * against the instance property set.
+  /**
+   * The value of `additionalProperties` MUST be a valid JSON Schema.
+   *
+   * The behavior of this keyword depends on the presence and annotation
+   * results of `properties` and `patternProperties` within the same
+   * schema object. Validation with `additionalProperties` applies only to
+   * the child values of instance names that do not appear in the annotation
+   * results of either `properties` or `patternProperties`.
+   *
+   * For all such properties, validation succeeds if the child instance
+   * validates against the `additionalProperties` schema.
+   *
+   * The annotation result of this keyword is the set of instance property
+   * names validated by this keyword's subschema. Annotation results for
+   * `additionalProperties` keywords from multiple schemas applied to the
+   * same instance location are combined by taking the union of the sets.
+   *
+   * Omitting this keyword has the same assertion behavior as an empty
+   * schema.
+   *
+   * Implementations MAY choose to implement or optimize this keyword in
+   * another way that produces the same effect, such as by directly checking
+   * the names in `properties` and the patterns in `patternProperties`
+   * against the instance property set.
    */
   additionalProperties?: JSONSchema;
-  /**
-   * This keyword's value MUST be a non-empty array. Each item of the array
-   * MUST be a valid JSON Schema.
-   *
-   * An instance validates successfully against this keyword if it validates
-   * successfully against all schemas defined by this keyword's value.
+  /**
+   * This keyword's value MUST be a non-empty array. Each item of the array
+   * MUST be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it validates
+   * successfully against all schemas defined by this keyword's value.
    */
   allOf?: MaybeReadonlyArray<JSONSchema<Value, SchemaType>>;
-  /**
-   * This keyword's value MUST be a non-empty array. Each item of the array
-   * MUST be a valid JSON Schema.
-   *
-   * An instance validates successfully against this keyword if it validates
-   * successfully against at least one schema defined by this keyword's
-   * value.
+  /**
+   * This keyword's value MUST be a non-empty array. Each item of the array
+   * MUST be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it validates
+   * successfully against at least one schema defined by this keyword's
+   * value.
    */
   anyOf?: MaybeReadonlyArray<JSONSchema<Value, SchemaType>>;
-  /**
-   * An instance validates successfully against this keyword if its value is
-   * equal to the value of the keyword.
-   *
-   * Use of this keyword is functionally equivalent to the `enum` keyword
-   * with a single value.
+  /**
+   * An instance validates successfully against this keyword if its value is
+   * equal to the value of the keyword.
+   *
+   * Use of this keyword is functionally equivalent to the `enum` keyword
+   * with a single value.
    */
   const?: Value;
-  /**
-   * The value of this keyword MUST be a valid JSON Schema.
-   *
-   * An array instance is valid against `contains` if at least one of its
-   * elements is valid against the given schema. The subschema MUST be
-   * applied to every array element even after the first match has been
-   * found, in order to collect annotations for use by other keywords.
-   * This is to ensure that all possible annotations are collected.
-   *
-   * Logically, the validation result of applying the value subschema to each
-   * item in the array MUST be OR'ed with `false`, resulting in an overall
-   * validation result.
-   *
-   * This keyword produces an annotation value which is an array of the
-   * indexes to which this keyword validates successfully when applying its
-   * subschema, in ascending order. The value MAY be a boolean `true` if
-   * the subschema validates successfully when applied to every index of the
-   * instance. The annotation MUST be present if the instance array to which
-   * this keyword's schema applies is empty.
+  /**
+   * The value of this keyword MUST be a valid JSON Schema.
+   *
+   * An array instance is valid against `contains` if at least one of its
+   * elements is valid against the given schema. The subschema MUST be
+   * applied to every array element even after the first match has been
+   * found, in order to collect annotations for use by other keywords.
+   * This is to ensure that all possible annotations are collected.
+   *
+   * Logically, the validation result of applying the value subschema to each
+   * item in the array MUST be OR'ed with `false`, resulting in an overall
+   * validation result.
+   *
+   * This keyword produces an annotation value which is an array of the
+   * indexes to which this keyword validates successfully when applying its
+   * subschema, in ascending order. The value MAY be a boolean `true` if
+   * the subschema validates successfully when applied to every index of the
+   * instance. The annotation MUST be present if the instance array to which
+   * this keyword's schema applies is empty.
    */
   contains?: JSONSchema<Value, SchemaType>;
-  /**
-   * If the instance value is a string, this property defines that the
-   * string SHOULD be interpreted as binary data and decoded using the
-   * encoding named by this property. [RFC 2045, Sec 6.1][RFC2045] lists the
-   * possible values for this property.
-   *
-   * The value of this property SHOULD be ignored if the instance described
-   * is not a string.
-   *
-   * If this keyword is absent, but `contentMediaType` is present, this
-   * indicates that the media type could be encoded into `UTF-8` like any
-   * other JSON string value, and does not require additional decoding.
-   *
-   * The value of this property MUST be a string.
-   *
-   * [RFC2045]: https://datatracker.ietf.org/doc/html/rfc2045#section-6.1
+  /**
+   * If the instance value is a string, this property defines that the
+   * string SHOULD be interpreted as binary data and decoded using the
+   * encoding named by this property. [RFC 2045, Sec 6.1][RFC2045] lists the
+   * possible values for this property.
+   *
+   * The value of this property SHOULD be ignored if the instance described
+   * is not a string.
+   *
+   * If this keyword is absent, but `contentMediaType` is present, this
+   * indicates that the media type could be encoded into `UTF-8` like any
+   * other JSON string value, and does not require additional decoding.
+   *
+   * The value of this property MUST be a string.
+   *
+   * [RFC2045]: https://datatracker.ietf.org/doc/html/rfc2045#section-6.1
    */
   contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
-  /**
-   * If the instance is a string, this property indicates the media type
-   * of the contents of the string.  If `contentEncoding` is present,
-   * this property describes the decoded string.
-   *
-   * The value of this property must be a media type, as defined by
-   * [RFC 2046][RFC2046]. This property defines the media type of instances
-   * which this schema defines.
-   *
-   * The value of this property SHOULD be ignored if the instance described
-   * is not a string.
-   *
-   * If the `contentEncoding` property is not present, but the instance
-   * value is a string, then the value of this property SHOULD specify a text
-   * document type, and the character set SHOULD be the character set into
-   * which the JSON string value was decoded (for which the default is
-   * Unicode).
-   *
-   * [RFC2046]: https://datatracker.ietf.org/doc/html/rfc2046
+  /**
+   * If the instance is a string, this property indicates the media type
+   * of the contents of the string.  If `contentEncoding` is present,
+   * this property describes the decoded string.
+   *
+   * The value of this property must be a media type, as defined by
+   * [RFC 2046][RFC2046]. This property defines the media type of instances
+   * which this schema defines.
+   *
+   * The value of this property SHOULD be ignored if the instance described
+   * is not a string.
+   *
+   * If the `contentEncoding` property is not present, but the instance
+   * value is a string, then the value of this property SHOULD specify a text
+   * document type, and the character set SHOULD be the character set into
+   * which the JSON string value was decoded (for which the default is
+   * Unicode).
+   *
+   * [RFC2046]: https://datatracker.ietf.org/doc/html/rfc2046
    */
   contentMediaType?: string;
-  /**
-   * If the instance is a string, and if `contentMediaType` is present,
-   * this property contains a schema which describes the structure of the
-   * string.
-   *
-   * This keyword MAY be used with any media type that can be mapped into
-   * JSON Schema's data model.
-   *
-   * The value of this property MUST be a valid JSON schema. It SHOULD be
-   * ignored if `contentMediaType` is not present.
+  /**
+   * If the instance is a string, and if `contentMediaType` is present,
+   * this property contains a schema which describes the structure of the
+   * string.
+   *
+   * This keyword MAY be used with any media type that can be mapped into
+   * JSON Schema's data model.
+   *
+   * The value of this property MUST be a valid JSON schema. It SHOULD be
+   * ignored if `contentMediaType` is not present.
    */
   contentSchema?: JSONSchema<Value, SchemaType>;
-  /**
-   * This keyword can be used to supply a default JSON value associated with
-   * a particular schema. It is RECOMMENDED that a `default` value be valid
-   * against the associated schema.
+  /**
+   * This keyword can be used to supply a default JSON value associated with
+   * a particular schema. It is RECOMMENDED that a `default` value be valid
+   * against the associated schema.
    */
   default?: Value;
-  /**
-   * @deprecated `definitions` has been renamed to `$defs`.
+  /**
+   * @deprecated `definitions` has been renamed to `$defs`.
    */
   definitions?: Record<string, JSONSchema>;
-  /**
-   * @deprecated `dependencies` has been split into two keywords:
-   * `dependentSchemas` and `dependentRequired`.
+  /**
+   * @deprecated `dependencies` has been split into two keywords:
+   * `dependentSchemas` and `dependentRequired`.
    */
   dependencies?: Record<string, MaybeReadonlyArray<string> | JSONSchema>;
-  /**
-   * The value of this keyword MUST be an object.  Properties in
-   * this object, if any, MUST be arrays.  Elements in each array,
-   * if any, MUST be strings, and MUST be unique.
-   *
-   * This keyword specifies properties that are required if a specific
-   * other property is present.  Their requirement is dependent on the
-   * presence of the other property.
-   *
-   * Validation succeeds if, for each name that appears in both
-   * the instance and as a name within this keyword's value, every
-   * item in the corresponding array is also the name of a property
-   * in the instance.
-   *
-   * Omitting this keyword has the same behavior as an empty object.
+  /**
+   * The value of this keyword MUST be an object.  Properties in
+   * this object, if any, MUST be arrays.  Elements in each array,
+   * if any, MUST be strings, and MUST be unique.
+   *
+   * This keyword specifies properties that are required if a specific
+   * other property is present.  Their requirement is dependent on the
+   * presence of the other property.
+   *
+   * Validation succeeds if, for each name that appears in both
+   * the instance and as a name within this keyword's value, every
+   * item in the corresponding array is also the name of a property
+   * in the instance.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
    */
   dependentRequired?: Record<string, MaybeReadonlyArray<string>>;
-  /**
-   * This keyword specifies subschemas that are evaluated if the instance is
-   * an object and contains a certain property.
-   *
-   * This keyword's value MUST be an object. Each value in the object MUST be
-   * a valid JSON Schema.
-   *
-   * If the object key is a property in the instance, the entire instance
-   * must validate against the subschema. Its use is dependent on the
-   * presence of the property.
-   *
-   * Omitting this keyword has the same behavior as an empty object.
+  /**
+   * This keyword specifies subschemas that are evaluated if the instance is
+   * an object and contains a certain property.
+   *
+   * This keyword's value MUST be an object. Each value in the object MUST be
+   * a valid JSON Schema.
+   *
+   * If the object key is a property in the instance, the entire instance
+   * must validate against the subschema. Its use is dependent on the
+   * presence of the property.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
    */
   dependentSchemas?: Record<string, JSONSchema>;
-  /**
-   * The value of this keyword MUST be a boolean.  When multiple occurrences
-   * of this keyword are applicable to a single sub-instance, applications
-   * SHOULD consider the instance location to be deprecated if any occurrence
-   * specifies a `true` value.
-   *
-   * If `deprecated` has a value of boolean `true`, it indicates that
-   * applications SHOULD refrain from usage of the declared property. It MAY
-   * mean the property is going to be removed in the future.
-   *
-   * A root schema containing `deprecated` with a value of `true`
-   * indicates that the entire resource being described MAY be removed in the
-   * future.
-   *
-   * The `deprecated` keyword applies to each instance location to which
-   * the schema object containing the keyword successfully applies.  This can
-   * result in scenarios where every array item or object property is
-   * deprecated even though the containing array or object is not.
-   *
-   * Omitting this keyword has the same behavior as a value of `false`.
+  /**
+   * The value of this keyword MUST be a boolean.  When multiple occurrences
+   * of this keyword are applicable to a single sub-instance, applications
+   * SHOULD consider the instance location to be deprecated if any occurrence
+   * specifies a `true` value.
+   *
+   * If `deprecated` has a value of boolean `true`, it indicates that
+   * applications SHOULD refrain from usage of the declared property. It MAY
+   * mean the property is going to be removed in the future.
+   *
+   * A root schema containing `deprecated` with a value of `true`
+   * indicates that the entire resource being described MAY be removed in the
+   * future.
+   *
+   * The `deprecated` keyword applies to each instance location to which
+   * the schema object containing the keyword successfully applies.  This can
+   * result in scenarios where every array item or object property is
+   * deprecated even though the containing array or object is not.
+   *
+   * Omitting this keyword has the same behavior as a value of `false`.
    */
   deprecated?: boolean;
-  /**
-   * Can be used to decorate a user interface with explanation or information
-   * about the data produced.
+  /**
+   * Can be used to decorate a user interface with explanation or information
+   * about the data produced.
    */
   description?: string;
-  /**
-   * This keyword's value MUST be a valid JSON Schema.
-   *
-   * When `if` is present, and the instance fails to validate against its
-   * subschema, then validation succeeds against this keyword if the instance
-   * successfully validates against this keyword's subschema.
-   *
-   * This keyword has no effect when `if` is absent, or when the instance
-   * successfully validates against its subschema. Implementations MUST NOT
-   * evaluate the instance against this keyword, for either validation or
-   * annotation collection purposes, in such cases.
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * When `if` is present, and the instance fails to validate against its
+   * subschema, then validation succeeds against this keyword if the instance
+   * successfully validates against this keyword's subschema.
+   *
+   * This keyword has no effect when `if` is absent, or when the instance
+   * successfully validates against its subschema. Implementations MUST NOT
+   * evaluate the instance against this keyword, for either validation or
+   * annotation collection purposes, in such cases.
    */
   else?: JSONSchema<Value, SchemaType>;
-  /**
-   * The value of this keyword MUST be an array. This array SHOULD have at
-   * least one element. Elements in the array SHOULD be unique.
-   *
-   * An instance validates successfully against this keyword if its value is
-   * equal to one of the elements in this keyword's array value.
-   *
-   * Elements in the array might be of any type, including `null`.
+  /**
+   * The value of this keyword MUST be an array. This array SHOULD have at
+   * least one element. Elements in the array SHOULD be unique.
+   *
+   * An instance validates successfully against this keyword if its value is
+   * equal to one of the elements in this keyword's array value.
+   *
+   * Elements in the array might be of any type, including `null`.
    */
   enum?: MaybeReadonlyArray<Value>;
-  /**
-   * The value of this keyword MUST be an array. When multiple occurrences of
-   * this keyword are applicable to a single sub-instance, implementations
-   * MUST provide a flat array of all values rather than an array of arrays.
-   *
-   * This keyword can be used to provide sample JSON values associated with a
-   * particular schema, for the purpose of illustrating usage. It is
-   * RECOMMENDED that these values be valid against the associated schema.
-   *
-   * Implementations MAY use the value(s) of `default`, if present, as an
-   * additional example. If `examples` is absent, `default` MAY still be
-   * used in this manner.
+  /**
+   * The value of this keyword MUST be an array. When multiple occurrences of
+   * this keyword are applicable to a single sub-instance, implementations
+   * MUST provide a flat array of all values rather than an array of arrays.
+   *
+   * This keyword can be used to provide sample JSON values associated with a
+   * particular schema, for the purpose of illustrating usage. It is
+   * RECOMMENDED that these values be valid against the associated schema.
+   *
+   * Implementations MAY use the value(s) of `default`, if present, as an
+   * additional example. If `examples` is absent, `default` MAY still be
+   * used in this manner.
    */
   examples?: MaybeReadonlyArray<Value>;
-  /**
-   * The value of `exclusiveMaximum` MUST be a number, representing an
-   * exclusive upper limit for a numeric instance.
-   *
-   * If the instance is a number, then the instance is valid only if it has a
-   * value strictly less than (not equal to) `exclusiveMaximum`.
+  /**
+   * The value of `exclusiveMaximum` MUST be a number, representing an
+   * exclusive upper limit for a numeric instance.
+   *
+   * If the instance is a number, then the instance is valid only if it has a
+   * value strictly less than (not equal to) `exclusiveMaximum`.
    */
   exclusiveMaximum?: number;
-  /**
-   * The value of `exclusiveMinimum` MUST be a number, representing an
-   * exclusive lower limit for a numeric instance.
-   *
-   * If the instance is a number, then the instance is valid only if it has a
-   * value strictly greater than (not equal to) `exclusiveMinimum`.
+  /**
+   * The value of `exclusiveMinimum` MUST be a number, representing an
+   * exclusive lower limit for a numeric instance.
+   *
+   * If the instance is a number, then the instance is valid only if it has a
+   * value strictly greater than (not equal to) `exclusiveMinimum`.
    */
   exclusiveMinimum?: number;
-  /**
-   * Implementations MAY treat `format` as an assertion in addition to an
-   * annotation, and attempt to validate the value's conformance to the
-   * specified semantics.
-   *
-   * The value of this keyword is called a format attribute. It MUST be a
-   * string. A format attribute can generally only validate a given set
-   * of instance types. If the type of the instance to validate is not in
-   * this set, validation for this format attribute and instance SHOULD
-   * succeed. Format attributes are most often applied to strings, but can
-   * be specified to apply to any type.
-   *
-   * Implementations MAY support custom format attributes. Save for agreement
-   * between parties, schema authors SHALL NOT expect a peer implementation
-   * to support such custom format attributes.  An implementation MUST NOT
-   * fail validation or cease processing due to an unknown format attribute.
-   * When treating `format` as an annotation, implementations SHOULD
-   * collect both known and unknown format attribute values.
+  /**
+   * Implementations MAY treat `format` as an assertion in addition to an
+   * annotation, and attempt to validate the value's conformance to the
+   * specified semantics.
+   *
+   * The value of this keyword is called a format attribute. It MUST be a
+   * string. A format attribute can generally only validate a given set
+   * of instance types. If the type of the instance to validate is not in
+   * this set, validation for this format attribute and instance SHOULD
+   * succeed. Format attributes are most often applied to strings, but can
+   * be specified to apply to any type.
+   *
+   * Implementations MAY support custom format attributes. Save for agreement
+   * between parties, schema authors SHALL NOT expect a peer implementation
+   * to support such custom format attributes.  An implementation MUST NOT
+   * fail validation or cease processing due to an unknown format attribute.
+   * When treating `format` as an annotation, implementations SHOULD
+   * collect both known and unknown format attribute values.
    */
   format?: string;
-  /**
-   * This keyword's value MUST be a valid JSON Schema.
-   *
-   * This validation outcome of this keyword's subschema has no direct effect
-   * on the overall validation result. Rather, it controls which of the
-   * `then` or `else` keywords are evaluated.
-   *
-   * Instances that successfully validate against this keyword's subschema
-   * MUST also be valid against the subschema value of the `then` keyword,
-   * if present.
-   *
-   * Instances that fail to validate against this keyword's subschema MUST
-   * also be valid against the subschema value of the `else` keyword, if
-   * present.
-   *
-   * If annotations are being collected, they are collected
-   * from this keyword's subschema in the usual way, including when the
-   * keyword is present without either `then` or `else`.
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * This validation outcome of this keyword's subschema has no direct effect
+   * on the overall validation result. Rather, it controls which of the
+   * `then` or `else` keywords are evaluated.
+   *
+   * Instances that successfully validate against this keyword's subschema
+   * MUST also be valid against the subschema value of the `then` keyword,
+   * if present.
+   *
+   * Instances that fail to validate against this keyword's subschema MUST
+   * also be valid against the subschema value of the `else` keyword, if
+   * present.
+   *
+   * If annotations are being collected, they are collected
+   * from this keyword's subschema in the usual way, including when the
+   * keyword is present without either `then` or `else`.
    */
   if?: JSONSchema<Value, SchemaType>;
-  /**
-   * The value of `items` MUST be a valid JSON Schema.
-   *
-   * This keyword applies its subschema to all instance elements at indexes
-   * greater than the length of the `prefixItems` array in the same schema
-   * object, as reported by the annotation result of that `prefixItems`
-   * keyword.  If no such annotation result exists, `items` applies its
-   * subschema to all instance array elements.
-   *
-   * Note that the behavior of `items` without `prefixItems` is identical
-   * to that of the schema form of `items` in prior drafts.
-   *
-   * When `prefixItems` is present, the behavior of `items` is identical
-   * to the former `additionalItems` keyword.
-   *
-   * If the `items` subschema is applied to any positions within the
-   * instance array, it produces an annotation result of boolean `true`,
-   * indicating that all remaining array elements have been evaluated against
-   * this keyword's subschema.
-   *
-   * Omitting this keyword has the same assertion behavior as an empty
-   * schema.
-   *
-   * Implementations MAY choose to implement or optimize this keyword
-   * in another way that produces the same effect, such as by directly
-   * checking for the presence and size of a `prefixItems` array.
+  /**
+   * The value of `items` MUST be a valid JSON Schema.
+   *
+   * This keyword applies its subschema to all instance elements at indexes
+   * greater than the length of the `prefixItems` array in the same schema
+   * object, as reported by the annotation result of that `prefixItems`
+   * keyword.  If no such annotation result exists, `items` applies its
+   * subschema to all instance array elements.
+   *
+   * Note that the behavior of `items` without `prefixItems` is identical
+   * to that of the schema form of `items` in prior drafts.
+   *
+   * When `prefixItems` is present, the behavior of `items` is identical
+   * to the former `additionalItems` keyword.
+   *
+   * If the `items` subschema is applied to any positions within the
+   * instance array, it produces an annotation result of boolean `true`,
+   * indicating that all remaining array elements have been evaluated against
+   * this keyword's subschema.
+   *
+   * Omitting this keyword has the same assertion behavior as an empty
+   * schema.
+   *
+   * Implementations MAY choose to implement or optimize this keyword
+   * in another way that produces the same effect, such as by directly
+   * checking for the presence and size of a `prefixItems` array.
    */
   items?: JSONSchema;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * If `contains` is not present within the same schema object, then this
-   * keyword has no effect.
-   *
-   * An instance array is valid against `maxContains` in two ways,
-   * depending on the form of the annotation result of an adjacent
-   * `contains` keyword. The first way is if the annotation result is an
-   * array and the length of that array is less than or equal to the
-   * `maxContains` value. The second way is if the annotation result is a
-   * boolean `true` and the instance array length is less than or equal to
-   * the `maxContains` value.
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * If `contains` is not present within the same schema object, then this
+   * keyword has no effect.
+   *
+   * An instance array is valid against `maxContains` in two ways,
+   * depending on the form of the annotation result of an adjacent
+   * `contains` keyword. The first way is if the annotation result is an
+   * array and the length of that array is less than or equal to the
+   * `maxContains` value. The second way is if the annotation result is a
+   * boolean `true` and the instance array length is less than or equal to
+   * the `maxContains` value.
    */
   maxContains?: number;
-  /**
-   * The value of `maximum` MUST be a number, representing an inclusive
-   * upper limit for a numeric instance.
-   *
-   * If the instance is a number, then this keyword validates only if the
-   * instance is less than or exactly equal to `maximum`.
+  /**
+   * The value of `maximum` MUST be a number, representing an inclusive
+   * upper limit for a numeric instance.
+   *
+   * If the instance is a number, then this keyword validates only if the
+   * instance is less than or exactly equal to `maximum`.
    */
   maximum?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * An array instance is valid against `maxItems` if its size is less
-   * than, or equal to, the value of this keyword.
-   *
-   * @minimum 0
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An array instance is valid against `maxItems` if its size is less
+   * than, or equal to, the value of this keyword.
+   *
+   * @minimum 0
    */
   maxItems?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * A string instance is valid against this keyword if its length is less
-   * than, or equal to, the value of this keyword.
-   *
-   * The length of a string instance is defined as the number of its
-   * characters as defined by [RFC 8259][RFC8259].
-   *
-   * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
-   *
-   * @minimum 0
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * A string instance is valid against this keyword if its length is less
+   * than, or equal to, the value of this keyword.
+   *
+   * The length of a string instance is defined as the number of its
+   * characters as defined by [RFC 8259][RFC8259].
+   *
+   * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
+   *
+   * @minimum 0
    */
   maxLength?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * An object instance is valid against `maxProperties` if its number of
-   * `properties` is less than, or equal to, the value of this keyword.
-   *
-   * @minimum 0
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An object instance is valid against `maxProperties` if its number of
+   * `properties` is less than, or equal to, the value of this keyword.
+   *
+   * @minimum 0
    */
   maxProperties?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * If `contains` is not present within the same schema object, then this
-   * keyword has no effect.
-   *
-   * An instance array is valid against `minContains` in two ways,
-   * depending on the form of the annotation result of an adjacent
-   * `contains` keyword. The first way is if the annotation result is an
-   * array and the length of that array is greater than or equal to the
-   * `minContains` value. The second way is if the annotation result is a
-   * boolean `true` and the instance array length is greater than or equal
-   * to the `minContains` value.
-   *
-   * A value of `0` is allowed, but is only useful for setting a range
-   * of occurrences from `0` to the value of `maxContains`.  A value of
-   * `0` with no `maxContains` causes `contains` to always pass
-   * validation.
-   *
-   * Omitting this keyword has the same behavior as a value of `1`.
-   *
-   * @default 1
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * If `contains` is not present within the same schema object, then this
+   * keyword has no effect.
+   *
+   * An instance array is valid against `minContains` in two ways,
+   * depending on the form of the annotation result of an adjacent
+   * `contains` keyword. The first way is if the annotation result is an
+   * array and the length of that array is greater than or equal to the
+   * `minContains` value. The second way is if the annotation result is a
+   * boolean `true` and the instance array length is greater than or equal
+   * to the `minContains` value.
+   *
+   * A value of `0` is allowed, but is only useful for setting a range
+   * of occurrences from `0` to the value of `maxContains`.  A value of
+   * `0` with no `maxContains` causes `contains` to always pass
+   * validation.
+   *
+   * Omitting this keyword has the same behavior as a value of `1`.
+   *
+   * @default 1
    */
   minContains?: number;
-  /**
-   * The value of `minimum` MUST be a number, representing an inclusive
-   * lower limit for a numeric instance.
-   *
-   * If the instance is a number, then this keyword validates only if the
-   * instance is greater than or exactly equal to `minimum`.
+  /**
+   * The value of `minimum` MUST be a number, representing an inclusive
+   * lower limit for a numeric instance.
+   *
+   * If the instance is a number, then this keyword validates only if the
+   * instance is greater than or exactly equal to `minimum`.
    */
   minimum?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * An array instance is valid against `minItems` if its size is greater
-   * than, or equal to, the value of this keyword.
-   *
-   * Omitting this keyword has the same behavior as a value of `0`.
-   *
-   * @default 0
-   * @minimum 0
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An array instance is valid against `minItems` if its size is greater
+   * than, or equal to, the value of this keyword.
+   *
+   * Omitting this keyword has the same behavior as a value of `0`.
+   *
+   * @default 0
+   * @minimum 0
    */
   minItems?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * A string instance is valid against this keyword if its length is greater
-   * than, or equal to, the value of this keyword.
-   *
-   * The length of a string instance is defined as the number of its
-   * characters as defined by [RFC 8259][RFC8259].
-   *
-   * Omitting this keyword has the same behavior as a value of `0`.
-   *
-   * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
-   *
-   * @default 0
-   * @minimum 0
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * A string instance is valid against this keyword if its length is greater
+   * than, or equal to, the value of this keyword.
+   *
+   * The length of a string instance is defined as the number of its
+   * characters as defined by [RFC 8259][RFC8259].
+   *
+   * Omitting this keyword has the same behavior as a value of `0`.
+   *
+   * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
+   *
+   * @default 0
+   * @minimum 0
    */
   minLength?: number;
-  /**
-   * The value of this keyword MUST be a non-negative integer.
-   *
-   * An object instance is valid against `minProperties` if its number of
-   * `properties` is greater than, or equal to, the value of this keyword.
-   *
-   * Omitting this keyword has the same behavior as a value of `0`.
-   *
-   * @default 0
-   * @minimum 0
+  /**
+   * The value of this keyword MUST be a non-negative integer.
+   *
+   * An object instance is valid against `minProperties` if its number of
+   * `properties` is greater than, or equal to, the value of this keyword.
+   *
+   * Omitting this keyword has the same behavior as a value of `0`.
+   *
+   * @default 0
+   * @minimum 0
    */
   minProperties?: number;
-  /**
-   * The value of `multipleOf` MUST be a number, strictly greater than
-   * `0`.
-   *
-   * A numeric instance is valid only if division by this keyword's value
-   * results in an integer.
-   *
-   * @exclusiveMinimum 0
+  /**
+   * The value of `multipleOf` MUST be a number, strictly greater than
+   * `0`.
+   *
+   * A numeric instance is valid only if division by this keyword's value
+   * results in an integer.
+   *
+   * @exclusiveMinimum 0
    */
   multipleOf?: number;
-  /**
-   * This keyword's value MUST be a valid JSON Schema.
-   *
-   * An instance is valid against this keyword if it fails to validate
-   * successfully against the schema defined by this keyword.
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * An instance is valid against this keyword if it fails to validate
+   * successfully against the schema defined by this keyword.
    */
   not?: JSONSchema<Value, SchemaType>;
-  /**
-   * This keyword's value MUST be a non-empty array. Each item of the array
-   * MUST be a valid JSON Schema.
-   *
-   * An instance validates successfully against this keyword if it validates
-   * successfully against exactly one schema defined by this keyword's value.
+  /**
+   * This keyword's value MUST be a non-empty array. Each item of the array
+   * MUST be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it validates
+   * successfully against exactly one schema defined by this keyword's value.
    */
   oneOf?: MaybeReadonlyArray<JSONSchema<Value, SchemaType>>;
-  /**
-   * The value of this keyword MUST be a string. This string SHOULD be a
-   * valid regular expression, according to the [ECMA-262][ecma262] regular
-   * expression dialect.
-   *
-   * A string instance is considered valid if the regular expression matches
-   * the instance successfully. Recall: regular expressions are not
-   * implicitly anchored.
-   *
-   * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
-   *
-   * @format "regex"
+  /**
+   * The value of this keyword MUST be a string. This string SHOULD be a
+   * valid regular expression, according to the [ECMA-262][ecma262] regular
+   * expression dialect.
+   *
+   * A string instance is considered valid if the regular expression matches
+   * the instance successfully. Recall: regular expressions are not
+   * implicitly anchored.
+   *
+   * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
+   *
+   * @format "regex"
    */
   pattern?: string;
-  /**
-   * The value of `patternProperties` MUST be an object. Each property name
-   * of this object SHOULD be a valid regular expression, according to the
-   * [ECMA-262][ecma262] regular expression dialect. Each property value of
-   * this object MUST be a valid JSON Schema.
-   *
-   * Validation succeeds if, for each instance name that matches any regular
-   * expressions that appear as a property name in this keyword's value,
-   * the child instance for that name successfully validates against each
-   * schema that corresponds to a matching regular expression.
-   *
-   * The annotation result of this keyword is the set of instance property
-   * names matched by this keyword. Omitting this keyword has the same
-   * assertion behavior as an empty object.
-   *
-   * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
+  /**
+   * The value of `patternProperties` MUST be an object. Each property name
+   * of this object SHOULD be a valid regular expression, according to the
+   * [ECMA-262][ecma262] regular expression dialect. Each property value of
+   * this object MUST be a valid JSON Schema.
+   *
+   * Validation succeeds if, for each instance name that matches any regular
+   * expressions that appear as a property name in this keyword's value,
+   * the child instance for that name successfully validates against each
+   * schema that corresponds to a matching regular expression.
+   *
+   * The annotation result of this keyword is the set of instance property
+   * names matched by this keyword. Omitting this keyword has the same
+   * assertion behavior as an empty object.
+   *
+   * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
    */
   patternProperties?: Record<string, JSONSchema>;
-  /**
-   * The value of `prefixItems` MUST be a non-empty array of valid JSON
-   * Schemas.
-   *
-   * Validation succeeds if each element of the instance validates against
-   * the schema at the same position, if any.  This keyword does not
-   * constrain the length of the array.  If the array is longer than this
-   * keyword's value, this keyword validates only the prefix of matching
-   * length.
-   *
-   * This keyword produces an annotation value which is the largest index to
-   * which this keyword applied a subschema.  The value MAY be a boolean
-   * `true` if a subschema was applied to every index of the instance, such
-   * as is produced by the `items` keyword.
-   * This annotation affects the behavior of `items` and
-   * `unevaluatedItems`.
-   *
-   * Omitting this keyword has the same assertion behavior as an empty array.
+  /**
+   * The value of `prefixItems` MUST be a non-empty array of valid JSON
+   * Schemas.
+   *
+   * Validation succeeds if each element of the instance validates against
+   * the schema at the same position, if any.  This keyword does not
+   * constrain the length of the array.  If the array is longer than this
+   * keyword's value, this keyword validates only the prefix of matching
+   * length.
+   *
+   * This keyword produces an annotation value which is the largest index to
+   * which this keyword applied a subschema.  The value MAY be a boolean
+   * `true` if a subschema was applied to every index of the instance, such
+   * as is produced by the `items` keyword.
+   * This annotation affects the behavior of `items` and
+   * `unevaluatedItems`.
+   *
+   * Omitting this keyword has the same assertion behavior as an empty array.
    */
   prefixItems?: MaybeReadonlyArray<JSONSchema> | JSONSchema;
-  /**
-   * The value of `properties` MUST be an object. Each value of this object
-   * MUST be a valid JSON Schema.
-   *
-   * Validation succeeds if, for each name that appears in both the instance
-   * and as a name within this keyword's value, the child instance for that
-   * name successfully validates against the corresponding schema.
-   *
-   * The annotation result of this keyword is the set of instance property
-   * names matched by this keyword.
-   *
-   * Omitting this keyword has the same assertion behavior as an empty
-   * object.
+  /**
+   * The value of `properties` MUST be an object. Each value of this object
+   * MUST be a valid JSON Schema.
+   *
+   * Validation succeeds if, for each name that appears in both the instance
+   * and as a name within this keyword's value, the child instance for that
+   * name successfully validates against the corresponding schema.
+   *
+   * The annotation result of this keyword is the set of instance property
+   * names matched by this keyword.
+   *
+   * Omitting this keyword has the same assertion behavior as an empty
+   * object.
    */
   properties?: Record<string, JSONSchema>;
-  /**
-   * The value of `propertyNames` MUST be a valid JSON Schema.
-   *
-   * If the instance is an object, this keyword validates if every property
-   * name in the instance validates against the provided schema.
-   * Note the property name that the schema is testing will always be a
-   * string.
-   *
-   * Omitting this keyword has the same behavior as an empty schema.
+  /**
+   * The value of `propertyNames` MUST be a valid JSON Schema.
+   *
+   * If the instance is an object, this keyword validates if every property
+   * name in the instance validates against the provided schema.
+   * Note the property name that the schema is testing will always be a
+   * string.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
    */
   propertyNames?: JSONSchema;
-  /**
-   * The value of this keyword MUST be a boolean. When multiple occurrences
-   * of this keyword are applicable to a single sub-instance, the resulting
-   * value MUST be `true` if any occurrence specifies a `true` value, and
-   * MUST be `false` otherwise.
-   *
-   * If `readOnly` has a value of boolean `true`, it indicates that the
-   * value of the instance is managed exclusively by the owning authority,
-   * and attempts by an application to modify the value of this property are
-   * expected to be ignored or rejected by that owning authority.
-   *
-   * An instance document that is marked as `readOnly` for the entire
-   * document MAY be ignored if sent to the owning authority, or MAY result
-   * in an error, at the authority's discretion.
-   *
-   * For example, `readOnly` would be used to mark a database-generated
-   * serial number as read-only.
-   *
-   * This keyword can be used to assist in user interface instance
-   * generation.
-   *
-   * @default false
+  /**
+   * The value of this keyword MUST be a boolean. When multiple occurrences
+   * of this keyword are applicable to a single sub-instance, the resulting
+   * value MUST be `true` if any occurrence specifies a `true` value, and
+   * MUST be `false` otherwise.
+   *
+   * If `readOnly` has a value of boolean `true`, it indicates that the
+   * value of the instance is managed exclusively by the owning authority,
+   * and attempts by an application to modify the value of this property are
+   * expected to be ignored or rejected by that owning authority.
+   *
+   * An instance document that is marked as `readOnly` for the entire
+   * document MAY be ignored if sent to the owning authority, or MAY result
+   * in an error, at the authority's discretion.
+   *
+   * For example, `readOnly` would be used to mark a database-generated
+   * serial number as read-only.
+   *
+   * This keyword can be used to assist in user interface instance
+   * generation.
+   *
+   * @default false
    */
   readOnly?: boolean;
-  /**
-   * The value of this keyword MUST be an array. Elements of this array, if
-   * any, MUST be strings, and MUST be unique.
-   *
-   * An object instance is valid against this keyword if every item in the
-   * array is the name of a property in the instance.
-   *
-   * Omitting this keyword has the same behavior as an empty array.
+  /**
+   * The value of this keyword MUST be an array. Elements of this array, if
+   * any, MUST be strings, and MUST be unique.
+   *
+   * An object instance is valid against this keyword if every item in the
+   * array is the name of a property in the instance.
+   *
+   * Omitting this keyword has the same behavior as an empty array.
    */
   required?: MaybeReadonlyArray<string>;
-  /**
-   * This keyword's value MUST be a valid JSON Schema.
-   *
-   * When `if` is present, and the instance successfully validates against
-   * its subschema, then validation succeeds against this keyword if the
-   * instance also successfully validates against this keyword's subschema.
-   *
-   * This keyword has no effect when `if` is absent, or when the instance
-   * fails to validate against its subschema. Implementations MUST NOT
-   * evaluate the instance against this keyword, for either validation or
-   * annotation collection purposes, in such cases.
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * When `if` is present, and the instance successfully validates against
+   * its subschema, then validation succeeds against this keyword if the
+   * instance also successfully validates against this keyword's subschema.
+   *
+   * This keyword has no effect when `if` is absent, or when the instance
+   * fails to validate against its subschema. Implementations MUST NOT
+   * evaluate the instance against this keyword, for either validation or
+   * annotation collection purposes, in such cases.
    */
   then?: JSONSchema<Value, SchemaType>;
-  /**
-   * Can be used to decorate a user interface with a short label about the
-   * data produced.
+  /**
+   * Can be used to decorate a user interface with a short label about the
+   * data produced.
    */
   title?: string;
-  /**
-   * The value of this keyword MUST be either a string or an array. If it is
-   * an array, elements of the array MUST be strings and MUST be unique.
-   *
-   * String values MUST be one of the six primitive types (`"null"`,
-   * `"boolean"`, `"object"`, `"array"`, `"number"`, or
-   * `"string"`), or `"integer"` which matches any number with a zero
-   * fractional part.
-   *
-   * An instance validates if and only if the instance is in any of the sets
-   * listed for this keyword.
+  /**
+   * The value of this keyword MUST be either a string or an array. If it is
+   * an array, elements of the array MUST be strings and MUST be unique.
+   *
+   * String values MUST be one of the six primitive types (`"null"`,
+   * `"boolean"`, `"object"`, `"array"`, `"number"`, or
+   * `"string"`), or `"integer"` which matches any number with a zero
+   * fractional part.
+   *
+   * An instance validates if and only if the instance is in any of the sets
+   * listed for this keyword.
    */
   type?: SchemaType;
-  /**
-   * The value of `unevaluatedItems` MUST be a valid JSON Schema.
-   *
-   * The behavior of this keyword depends on the annotation results of
-   * adjacent keywords that apply to the instance location being validated.
-   * Specifically, the annotations from `prefixItems`, `items`, and
-   * `contains`, which can come from those keywords when they are adjacent
-   * to the `unevaluatedItems` keyword. Those three annotations, as well as
-   * `unevaluatedItems`, can also result from any and all adjacent
-   * [in-place applicator][in-place-applicator] keywords.
-   *
-   * If no relevant annotations are present, the `unevaluatedItems`
-   * subschema MUST be applied to all locations in the array.
-   * If a boolean `true` value is present from any of the relevant
-   * annotations, `unevaluatedItems` MUST be ignored.  Otherwise, the
-   * subschema MUST be applied to any index greater than the largest
-   * annotation value for `prefixItems`, which does not appear in any
-   * annotation value for `contains`.
-   *
-   * This means that `prefixItems`, `items`, `contains`, and all
-   * in-place applicators MUST be evaluated before this keyword can be
-   * evaluated. Authors of extension keywords MUST NOT define an in-place
-   * applicator that would need to be evaluated after this keyword.
-   *
-   * If the `unevaluatedItems` subschema is applied to any positions within
-   * the instance array, it produces an annotation result of boolean
-   * `true`, analogous to the behavior of `items`.
-   *
-   * Omitting this keyword has the same assertion behavior as an empty
-   * schema.
-   *
-   * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
+  /**
+   * The value of `unevaluatedItems` MUST be a valid JSON Schema.
+   *
+   * The behavior of this keyword depends on the annotation results of
+   * adjacent keywords that apply to the instance location being validated.
+   * Specifically, the annotations from `prefixItems`, `items`, and
+   * `contains`, which can come from those keywords when they are adjacent
+   * to the `unevaluatedItems` keyword. Those three annotations, as well as
+   * `unevaluatedItems`, can also result from any and all adjacent
+   * [in-place applicator][in-place-applicator] keywords.
+   *
+   * If no relevant annotations are present, the `unevaluatedItems`
+   * subschema MUST be applied to all locations in the array.
+   * If a boolean `true` value is present from any of the relevant
+   * annotations, `unevaluatedItems` MUST be ignored.  Otherwise, the
+   * subschema MUST be applied to any index greater than the largest
+   * annotation value for `prefixItems`, which does not appear in any
+   * annotation value for `contains`.
+   *
+   * This means that `prefixItems`, `items`, `contains`, and all
+   * in-place applicators MUST be evaluated before this keyword can be
+   * evaluated. Authors of extension keywords MUST NOT define an in-place
+   * applicator that would need to be evaluated after this keyword.
+   *
+   * If the `unevaluatedItems` subschema is applied to any positions within
+   * the instance array, it produces an annotation result of boolean
+   * `true`, analogous to the behavior of `items`.
+   *
+   * Omitting this keyword has the same assertion behavior as an empty
+   * schema.
+   *
+   * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
    */
   unevaluatedItems?: JSONSchema;
-  /**
-   * The value of `unevaluatedProperties` MUST be a valid JSON Schema.
-   *
-   * The behavior of this keyword depends on the annotation results of
-   * adjacent keywords that apply to the instance location being validated.
-   * Specifically, the annotations from `properties`,
-   * `patternProperties`, and `additionalProperties`, which can come from
-   * those keywords when they are adjacent to the `unevaluatedProperties`
-   * keyword.  Those three annotations, as well as `unevaluatedProperties`,
-   * can also result from any and all adjacent
-   * [in-place applicator][in-place-applicator] keywords.
-   *
-   * Validation with `unevaluatedProperties` applies only to the child
-   * values of instance names that do not appear in the `properties`,
-   * `patternProperties`, `additionalProperties`, or
-   * `unevaluatedProperties` annotation results that apply to the
-   * instance location being validated.
-   *
-   * For all such properties, validation succeeds if the child instance
-   * validates against the "unevaluatedProperties" schema.
-   *
-   * This means that `properties`, `patternProperties`,
-   * `additionalProperties`, and all in-place applicators MUST be evaluated
-   * before this keyword can be evaluated.  Authors of extension keywords
-   * MUST NOT define an in-place applicator that would need to be evaluated
-   * after this keyword.
-   *
-   * The annotation result of this keyword is the set of instance property
-   * names validated by this keyword's subschema.
-   *
-   * Omitting this keyword has the same assertion behavior as an empty
-   * schema.
-   *
-   * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
+  /**
+   * The value of `unevaluatedProperties` MUST be a valid JSON Schema.
+   *
+   * The behavior of this keyword depends on the annotation results of
+   * adjacent keywords that apply to the instance location being validated.
+   * Specifically, the annotations from `properties`,
+   * `patternProperties`, and `additionalProperties`, which can come from
+   * those keywords when they are adjacent to the `unevaluatedProperties`
+   * keyword.  Those three annotations, as well as `unevaluatedProperties`,
+   * can also result from any and all adjacent
+   * [in-place applicator][in-place-applicator] keywords.
+   *
+   * Validation with `unevaluatedProperties` applies only to the child
+   * values of instance names that do not appear in the `properties`,
+   * `patternProperties`, `additionalProperties`, or
+   * `unevaluatedProperties` annotation results that apply to the
+   * instance location being validated.
+   *
+   * For all such properties, validation succeeds if the child instance
+   * validates against the "unevaluatedProperties" schema.
+   *
+   * This means that `properties`, `patternProperties`,
+   * `additionalProperties`, and all in-place applicators MUST be evaluated
+   * before this keyword can be evaluated.  Authors of extension keywords
+   * MUST NOT define an in-place applicator that would need to be evaluated
+   * after this keyword.
+   *
+   * The annotation result of this keyword is the set of instance property
+   * names validated by this keyword's subschema.
+   *
+   * Omitting this keyword has the same assertion behavior as an empty
+   * schema.
+   *
+   * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
    */
   unevaluatedProperties?: JSONSchema;
-  /**
-   * The value of this keyword MUST be a boolean.
-   *
-   * If this keyword has boolean value `false`, the instance validates
-   * successfully. If it has boolean value `true`, the instance validates
-   * successfully if all of its elements are unique.
-   *
-   * Omitting this keyword has the same behavior as a value of `false`.
-   *
-   * @default false
+  /**
+   * The value of this keyword MUST be a boolean.
+   *
+   * If this keyword has boolean value `false`, the instance validates
+   * successfully. If it has boolean value `true`, the instance validates
+   * successfully if all of its elements are unique.
+   *
+   * Omitting this keyword has the same behavior as a value of `false`.
+   *
+   * @default false
    */
   uniqueItems?: boolean;
-  /**
-   * The value of this keyword MUST be a boolean. When multiple occurrences
-   * of this keyword is applicable to a single sub-instance, the resulting
-   * value MUST be `true` if any occurrence specifies a `true` value, and
-   * MUST be `false` otherwise.
-   *
-   * If `writeOnly` has a value of boolean `true`, it indicates that the
-   * value is never present when the instance is retrieved from the owning
-   * authority. It can be present when sent to the owning authority to update
-   * or create the document (or the resource it represents), but it will not
-   * be included in any updated or newly created version of the instance.
-   *
-   * An instance document that is marked as `writeOnly` for the entire
-   * document MAY be returned as a blank document of some sort, or MAY
-   * produce an error upon retrieval, or have the retrieval request ignored,
-   * at the authority's discretion.
-   *
-   * For example, `writeOnly` would be used to mark a password input field.
-   *
-   * These keywords can be used to assist in user interface instance
-   * generation. In particular, an application MAY choose to use a widget
-   * that hides input values as they are typed for write-only fields.
-   *
-   * @default false
+  /**
+   * The value of this keyword MUST be a boolean. When multiple occurrences
+   * of this keyword is applicable to a single sub-instance, the resulting
+   * value MUST be `true` if any occurrence specifies a `true` value, and
+   * MUST be `false` otherwise.
+   *
+   * If `writeOnly` has a value of boolean `true`, it indicates that the
+   * value is never present when the instance is retrieved from the owning
+   * authority. It can be present when sent to the owning authority to update
+   * or create the document (or the resource it represents), but it will not
+   * be included in any updated or newly created version of the instance.
+   *
+   * An instance document that is marked as `writeOnly` for the entire
+   * document MAY be returned as a blank document of some sort, or MAY
+   * produce an error upon retrieval, or have the retrieval request ignored,
+   * at the authority's discretion.
+   *
+   * For example, `writeOnly` would be used to mark a password input field.
+   *
+   * These keywords can be used to assist in user interface instance
+   * generation. In particular, an application MAY choose to use a widget
+   * that hides input values as they are typed for write-only fields.
+   *
+   * @default false
    */
   writeOnly?: boolean;
 };
 declare namespace JSONSchema {
   type TypeValue = ValueOf<TypeName> | TypeName | Array<ValueOf<TypeName> | TypeName> | ReadonlyArray<ValueOf<TypeName> | TypeName>;
-  /**
-   * JSON Schema interface
+  /**
+   * JSON Schema interface
    */
   type Interface<Value = any, SchemaType extends TypeValue = TypeValue> = Exclude<JSONSchema<Value, SchemaType>, boolean>;
   type Array<T = any> = Pick<Interface<T, "array">, KeywordByType.Any | KeywordByType.Array>;
@@ -7053,45 +7477,45 @@ declare namespace KeywordByType {
   type Object = "additionalProperties" | "dependencies" | "dependentRequired" | "dependentSchemas" | "maxProperties" | "minProperties" | "patternProperties" | "properties" | "propertyNames" | "required" | "unevaluatedProperties";
   type String = "contentEncoding" | "contentMediaType" | "contentSchema" | "maxLength" | "minLength" | "pattern";
 }
-/**
- * Enum consisting of simple type names for the `type` keyword
+/**
+ * Enum consisting of simple type names for the `type` keyword
  */
 declare enum TypeName {
-  /**
-   * Value MUST be an array.
+  /**
+   * Value MUST be an array.
    */
   Array = "array",
-  /**
-   * Value MUST be a boolean.
+  /**
+   * Value MUST be a boolean.
    */
   Boolean = "boolean",
-  /**
-   * Value MUST be an integer, no floating point numbers are allowed. This is a
-   * subset of the number type.
+  /**
+   * Value MUST be an integer, no floating point numbers are allowed. This is a
+   * subset of the number type.
    */
   Integer = "integer",
-  /**
-   * Value MUST be null. Note this is mainly for purpose of being able use union
-   * types to define nullability. If this type is not included in a union, null
-   * values are not allowed (the primitives listed above do not allow nulls on
-   * their own).
+  /**
+   * Value MUST be null. Note this is mainly for purpose of being able use union
+   * types to define nullability. If this type is not included in a union, null
+   * values are not allowed (the primitives listed above do not allow nulls on
+   * their own).
    */
   Null = "null",
-  /**
-   * Value MUST be a number, floating point numbers are allowed.
+  /**
+   * Value MUST be a number, floating point numbers are allowed.
    */
   Number = "number",
-  /**
-   * Value MUST be an object.
+  /**
+   * Value MUST be an object.
    */
   Object = "object",
-  /**
-   * Value MUST be a string.
+  /**
+   * Value MUST be a string.
    */
   String = "string"
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@orpc+openapi@1.15.2_@opentelemetry+api@1.9.1_ws@8.21.3/node_modules/@orpc/openapi/dist/shared/openapi.BGy4N6eR.d.mts
+//#region ../../node_modules/.pnpm/@orpc+openapi@1.15.7_@opentelemetry+api@1.9.1_ws@8.22.0/node_modules/@orpc/openapi/dist/shared/openapi.BGy4N6eR.d.mts
 interface SchemaConverterComponent {
   allowedStrategies: readonly SchemaConvertOptions['strategy'][];
   schema: AnySchema;