@scalar/openapi-types 0.1.8 → 0.2.0

package/dist/schemas/3.1/unprocessed/server-object.js

@@ -0,0 +1,12 @@
+import { ServerObjectSchema as ServerObjectSchema$1 } from '../processed/server-object.js';
+
+/**
+ * Server Object
+ *
+ * An object representing a Server.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#server-object
+ */
+const ServerObjectSchema = ServerObjectSchema$1;
+
+export { ServerObjectSchema };

package/dist/schemas/3.1/unprocessed/server-variable-object.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Server Variable Object
+ *
+ * An object representing a Server Variable for server URL template substitution.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#server-variable-object
+ */
+export declare const ServerVariableObjectSchema: import("zod").ZodObject<{
+    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    default: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    description?: string | undefined;
+    default?: string | undefined;
+    enum?: string[] | undefined;
+}, {
+    description?: string | undefined;
+    default?: string | undefined;
+    enum?: string[] | undefined;
+}>;
+//# sourceMappingURL=server-variable-object.d.ts.map

package/dist/schemas/3.1/unprocessed/server-variable-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-variable-object.d.ts","sourceRoot":"","sources":["../../../../src/schemas/3.1/unprocessed/server-variable-object.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAAqC,CAAA"}

package/dist/schemas/3.1/unprocessed/server-variable-object.js

@@ -0,0 +1,12 @@
+import { ServerVariableObjectSchema as ServerVariableObjectSchema$1 } from '../processed/server-variable-object.js';
+
+/**
+ * Server Variable Object
+ *
+ * An object representing a Server Variable for server URL template substitution.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#server-variable-object
+ */
+const ServerVariableObjectSchema = ServerVariableObjectSchema$1;
+
+export { ServerVariableObjectSchema };

package/dist/schemas/3.1/unprocessed/tag-object.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tag Object
+ *
+ * Adds metadata to a single tag that is used by the Operation Object. It is not mandatory to have a Tag Object per tag
+ * defined in the Operation Object instances.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#tag-object
+ */
+export declare const TagObjectSchema: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    description: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+    externalDocs: import("zod").ZodOptional<import("zod").ZodObject<{
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+    }, {
+        url: string;
+        description?: string | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    name: string;
+    externalDocs?: {
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    externalDocs?: {
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    description?: unknown;
+}>;
+//# sourceMappingURL=tag-object.d.ts.map

package/dist/schemas/3.1/unprocessed/tag-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-object.d.ts","sourceRoot":"","sources":["../../../../src/schemas/3.1/unprocessed/tag-object.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0B,CAAA"}

package/dist/schemas/3.1/unprocessed/tag-object.js

@@ -0,0 +1,13 @@
+import { TagObjectSchema as TagObjectSchema$1 } from '../processed/tag-object.js';
+
+/**
+ * Tag Object
+ *
+ * Adds metadata to a single tag that is used by the Operation Object. It is not mandatory to have a Tag Object per tag
+ * defined in the Operation Object instances.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#tag-object
+ */
+const TagObjectSchema = TagObjectSchema$1;
+
+export { TagObjectSchema };

package/dist/schemas/3.1/unprocessed/webhooks-object.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+/**
+ * Webhooks Object
+ *
+ * The incoming webhooks that MAY be received as part of this API and that the API consumer MAY choose to implement.
+ * Closely related to the callbacks feature, this section describes requests initiated other than by an API call, for
+ * example by an out of band registration.
+ *
+ * The key name is a unique string to refer to each webhook, while the
+ * (optionally referenced) Path Item Object describes a request that may be initiated by the API provider and the
+ * expected responses. An example is available.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#oas-webhooks
+ */
+export declare const WebhooksObjectSchema: z.ZodRecord<z.ZodString, z.ZodType<{
+    servers?: {
+        url: string;
+        description?: string | undefined;
+        variables?: Record<string, {
+            description?: string | undefined;
+            default?: string | undefined;
+            enum?: string[] | undefined;
+        }> | undefined;
+    }[] | undefined;
+    description?: string | undefined;
+    summary?: string | undefined;
+    parameters?: ({
+        $ref: string;
+        description?: string | undefined;
+        summary?: string | undefined;
+    } | {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        description?: string | undefined;
+        deprecated?: boolean | undefined;
+        content?: Record<string, {
+            example?: any;
+            examples?: Record<string, {
+                description?: string | undefined;
+                summary?: string | undefined;
+                value?: any;
+                externalValue?: string | undefined;
+            } | {
+                $ref: string;
+                description?: string | undefined;
+                summary?: string | undefined;
+            }> | undefined;
+            schema?: any;
+            encoding?: Record<string, {
+                contentType: string;
+                headers?: Record<string, {
+                    $ref: string;
+                    description?: string | undefined;
+                    summary?: string | undefined;
+                } | {
+                    description?: string | undefined;
+                    deprecated?: boolean | undefined;
+                    content?: Record<string, {
+                        example?: any;
+                        examples?: Record<string, {
+                            description?: string | undefined;
+                            summary?: string | undefined;
+                            value?: any;
+                            externalValue?: string | undefined;
+                        }> | undefined;
+                        schema?: Record<string, any> | undefined;
+                    }> | undefined;
+                    required?: boolean | undefined;
+                    example?: any;
+                    examples?: Record<string, {
+                        description?: string | undefined;
+                        summary?: string | undefined;
+                        value?: any;
+                        externalValue?: string | undefined;
+                    } | {
+                        $ref: string;
+                        description?: string | undefined;
+                        summary?: string | undefined;
+                    }> | undefined;
+                    schema?: any;
+                    style?: "matrix" | "label" | "simple" | "form" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+                    explode?: boolean | undefined;
+                }> | undefined;
+            }> | undefined;
+        }> | undefined;
+        required?: boolean | undefined;
+        example?: any;
+        examples?: Record<string, {
+            description?: string | undefined;
+            summary?: string | undefined;
+            value?: any;
+            externalValue?: string | undefined;
+        } | {
+            $ref: string;
+            description?: string | undefined;
+            summary?: string | undefined;
+        }> | undefined;
+        schema?: Record<string, any> | undefined;
+        style?: "matrix" | "label" | "simple" | "form" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        explode?: boolean | undefined;
+        allowEmptyValue?: boolean | undefined;
+        allowReserved?: boolean | undefined;
+    })[] | undefined;
+} & {
+    get?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    put?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    post?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    delete?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    options?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    head?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    patch?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    trace?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+}, z.ZodTypeDef, {
+    servers?: {
+        url: string;
+        description?: string | undefined;
+        variables?: Record<string, {
+            description?: string | undefined;
+            default?: string | undefined;
+            enum?: string[] | undefined;
+        }> | undefined;
+    }[] | undefined;
+    description?: string | undefined;
+    summary?: string | undefined;
+    parameters?: ({
+        $ref: string;
+        description?: string | undefined;
+        summary?: string | undefined;
+    } | {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        description?: string | undefined;
+        deprecated?: boolean | undefined;
+        content?: Record<string, {
+            example?: any;
+            examples?: Record<string, {
+                description?: string | undefined;
+                summary?: string | undefined;
+                value?: any;
+                externalValue?: string | undefined;
+            } | {
+                $ref: string;
+                description?: string | undefined;
+                summary?: string | undefined;
+            }> | undefined;
+            schema?: any;
+            encoding?: Record<string, {
+                contentType: string;
+                headers?: Record<string, {
+                    $ref: string;
+                    description?: string | undefined;
+                    summary?: string | undefined;
+                } | {
+                    description?: string | undefined;
+                    deprecated?: boolean | undefined;
+                    content?: Record<string, {
+                        example?: any;
+                        examples?: Record<string, {
+                            description?: string | undefined;
+                            summary?: string | undefined;
+                            value?: any;
+                            externalValue?: string | undefined;
+                        }> | undefined;
+                        schema?: Record<string, any> | undefined;
+                    }> | undefined;
+                    required?: boolean | undefined;
+                    example?: any;
+                    examples?: Record<string, {
+                        description?: string | undefined;
+                        summary?: string | undefined;
+                        value?: any;
+                        externalValue?: string | undefined;
+                    } | {
+                        $ref: string;
+                        description?: string | undefined;
+                        summary?: string | undefined;
+                    }> | undefined;
+                    schema?: any;
+                    style?: "matrix" | "label" | "simple" | "form" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+                    explode?: boolean | undefined;
+                }> | undefined;
+            }> | undefined;
+        }> | undefined;
+        required?: boolean | undefined;
+        example?: any;
+        examples?: Record<string, {
+            description?: string | undefined;
+            summary?: string | undefined;
+            value?: any;
+            externalValue?: string | undefined;
+        } | {
+            $ref: string;
+            description?: string | undefined;
+            summary?: string | undefined;
+        }> | undefined;
+        schema?: Record<string, any> | undefined;
+        style?: "matrix" | "label" | "simple" | "form" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        explode?: boolean | undefined;
+        allowEmptyValue?: boolean | undefined;
+        allowReserved?: boolean | undefined;
+    })[] | undefined;
+} & {
+    get?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    put?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    post?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    delete?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    options?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    head?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    patch?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+    trace?: z.infer<typeof import("./operation-object-without-callbacks.js").OperationObjectSchemaWithoutCallbacks>;
+}>>;
+//# sourceMappingURL=webhooks-object.d.ts.map

package/dist/schemas/3.1/unprocessed/webhooks-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks-object.d.ts","sourceRoot":"","sources":["../../../../src/schemas/3.1/unprocessed/webhooks-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UATP,EAAG,KAAK;UAAsD,EAAG,KAAK;WAC/D,EAAG,KAAK;aAEW,EAAG,KAAK;cACb,EAAG,KAAK;WAAuD,EAC7G,KAAG;YAEK,EAAG,KAAK;YAAwD,EAAG,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAPpD,KAAK;YAAyD,KAAK;aAC5D,KAAK;eAEc,KAAK;gBACV,KAAK;aACtD,KAAG;cAEQ,KAAK;cAA2D,KAAK;GAEa,CAAA"}

package/dist/schemas/3.1/unprocessed/webhooks-object.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { PathItemObjectSchemaWithoutCallbacks } from './path-item-object-without-callbacks.js';
+
+/**
+ * Webhooks Object
+ *
+ * The incoming webhooks that MAY be received as part of this API and that the API consumer MAY choose to implement.
+ * Closely related to the callbacks feature, this section describes requests initiated other than by an API call, for
+ * example by an out of band registration.
+ *
+ * The key name is a unique string to refer to each webhook, while the
+ * (optionally referenced) Path Item Object describes a request that may be initiated by the API provider and the
+ * expected responses. An example is available.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#oas-webhooks
+ */
+const WebhooksObjectSchema = z.record(z.string(), PathItemObjectSchemaWithoutCallbacks);
+
+export { WebhooksObjectSchema };

package/dist/schemas/3.1/unprocessed/xml-object.d.ts

@@ -0,0 +1,31 @@
+/**
+ *
+ * XML Object
+ *
+ * A metadata object that allows for more fine-tuned XML model definitions.
+ *
+ * When using arrays, XML element names are not inferred (for singular/plural forms) and the name field SHOULD be used
+ * to add that information. See examples for expected behavior.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#xml-object
+ */
+export declare const XmlObjectSchema: import("zod").ZodObject<{
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    namespace: import("zod").ZodOptional<import("zod").ZodString>;
+    prefix: import("zod").ZodOptional<import("zod").ZodString>;
+    attribute: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    wrapped: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    name?: string | undefined;
+    namespace?: string | undefined;
+    prefix?: string | undefined;
+    attribute?: boolean | undefined;
+    wrapped?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    namespace?: string | undefined;
+    prefix?: string | undefined;
+    attribute?: boolean | undefined;
+    wrapped?: boolean | undefined;
+}>;
+//# sourceMappingURL=xml-object.d.ts.map

package/dist/schemas/3.1/unprocessed/xml-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-object.d.ts","sourceRoot":"","sources":["../../../../src/schemas/3.1/unprocessed/xml-object.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAA0B,CAAA"}

package/dist/schemas/3.1/unprocessed/xml-object.js

@@ -0,0 +1,16 @@
+import { XmlObjectSchema as XmlObjectSchema$1 } from '../processed/xml-object.js';
+
+/**
+ *
+ * XML Object
+ *
+ * A metadata object that allows for more fine-tuned XML model definitions.
+ *
+ * When using arrays, XML element names are not inferred (for singular/plural forms) and the name field SHOULD be used
+ * to add that information. See examples for expected behavior.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#xml-object
+ */
+const XmlObjectSchema = XmlObjectSchema$1;
+
+export { XmlObjectSchema };

package/dist/schemas/extensions/index.d.ts

@@ -0,0 +1,11 @@
+export { XAdditionalPropertiesNameSchema } from './x-additional-properties-name.js';
+export { XCodeSamplesSchema, XCodeSampleSchema } from './x-code-samples.js';
+export { XEnumDescriptionsSchema } from './x-enum-descriptions.js';
+export { XInternalSchema } from './x-internal.js';
+export { XScalarIconSchema } from './x-scalar-icon.js';
+export { XScalarIgnoreSchema } from './x-scalar-ignore.js';
+export { XScalarRedirectUriSchema } from './x-scalar-redirect-uri.js';
+export { XScalarStabilitySchema, XScalarStabilityValues } from './x-scalar-stability.js';
+export { XTagGroupsSchema, XTagGroupSchema } from './x-tag-groups.js';
+export { XusePkceSchema, XUsePkceValues } from './x-use-pkce.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/extensions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAA;AAChF,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AACrF,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAClE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/schemas/extensions/index.js

@@ -0,0 +1,10 @@
+export { XAdditionalPropertiesNameSchema } from './x-additional-properties-name.js';
+export { XCodeSampleSchema, XCodeSamplesSchema } from './x-code-samples.js';
+export { XEnumDescriptionsSchema } from './x-enum-descriptions.js';
+export { XInternalSchema } from './x-internal.js';
+export { XScalarIconSchema } from './x-scalar-icon.js';
+export { XScalarIgnoreSchema } from './x-scalar-ignore.js';
+export { XScalarRedirectUriSchema } from './x-scalar-redirect-uri.js';
+export { XScalarStabilitySchema, XScalarStabilityValues } from './x-scalar-stability.js';
+export { XTagGroupSchema, XTagGroupsSchema } from './x-tag-groups.js';
+export { XUsePkceValues, XusePkceSchema } from './x-use-pkce.js';

package/dist/schemas/extensions/x-additional-properties-name.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/**
+ * x-additionalPropertiesName
+ *
+ * Custom attribute name for additionalProperties in a schema.
+ * This allows specifying a descriptive name for additional properties
+ * that may be present in an object.
+ */
+export declare const XAdditionalPropertiesNameSchema: z.ZodObject<{
+    'x-additionalPropertiesName': z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    'x-additionalPropertiesName'?: string | undefined;
+}, {
+    'x-additionalPropertiesName'?: unknown;
+}>;
+//# sourceMappingURL=x-additional-properties-name.d.ts.map

package/dist/schemas/extensions/x-additional-properties-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-additional-properties-name.d.ts","sourceRoot":"","sources":["../../../src/schemas/extensions/x-additional-properties-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;;;;EAE1C,CAAA"}

package/dist/schemas/extensions/x-additional-properties-name.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+/**
+ * x-additionalPropertiesName
+ *
+ * Custom attribute name for additionalProperties in a schema.
+ * This allows specifying a descriptive name for additional properties
+ * that may be present in an object.
+ */
+const XAdditionalPropertiesNameSchema = z.object({
+    'x-additionalPropertiesName': z.string().optional().catch(undefined),
+});
+
+export { XAdditionalPropertiesNameSchema };

package/dist/schemas/extensions/x-code-samples.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const XCodeSampleSchema: z.ZodObject<{
+    lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    source: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    label?: string | undefined;
+    lang?: string | undefined;
+}, {
+    source: string;
+    label?: unknown;
+    lang?: unknown;
+}>;
+export declare const XCodeSamplesSchema: z.ZodObject<{
+    'x-codeSamples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+    'x-code-samples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+    'x-custom-examples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    'x-codeSamples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+    'x-code-samples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+    'x-custom-examples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+}, {
+    'x-codeSamples'?: unknown;
+    'x-code-samples'?: unknown;
+    'x-custom-examples'?: unknown;
+}>;
+//# sourceMappingURL=x-code-samples.d.ts.map

package/dist/schemas/extensions/x-code-samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../src/schemas/extensions/x-code-samples.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI7B,CAAA"}

package/dist/schemas/extensions/x-code-samples.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+const XCodeSampleSchema = z.object({
+    lang: z.string().optional().catch(undefined),
+    label: z.string().optional().catch(undefined),
+    source: z.string(),
+});
+const XCodeSamplesSchema = z.object({
+    'x-codeSamples': XCodeSampleSchema.array().optional().catch(undefined),
+    'x-code-samples': XCodeSampleSchema.array().optional().catch(undefined),
+    'x-custom-examples': XCodeSampleSchema.array().optional().catch(undefined),
+});
+
+export { XCodeSampleSchema, XCodeSamplesSchema };

package/dist/schemas/extensions/x-display-name.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * An OpenAPI extension to overwrite tag names with a display-friendly version
+ *
+ * @example
+ * ```yaml
+ * x-displayName: planets
+ * ```
+ */
+export declare const XDisplayNameSchema: z.ZodObject<{
+    'x-displayName': z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    'x-displayName'?: string | undefined;
+}, {
+    'x-displayName'?: unknown;
+}>;
+//# sourceMappingURL=x-display-name.d.ts.map

package/dist/schemas/extensions/x-display-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-display-name.d.ts","sourceRoot":"","sources":["../../../src/schemas/extensions/x-display-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;EAE7B,CAAA"}

package/dist/schemas/extensions/x-enum-descriptions.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+/**
+ * x-enumDescriptions
+ *
+ * Maps enum values to their descriptions. Each key should correspond to
+ * an enum value, and the value is the description for that enum value.
+ *
+ * Example:
+ * x-enumDescriptions:
+ *   missing_features: "Missing features"
+ *   too_expensive: "Too expensive"
+ *   unused: "Unused"
+ *   other: "Other"
+ */
+export declare const XEnumDescriptionsSchema: z.ZodObject<{
+    'x-enumDescriptions': z.ZodCatch<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    'x-enumDescriptions': Record<string, string>;
+}, {
+    'x-enumDescriptions'?: unknown;
+}>;
+//# sourceMappingURL=x-enum-descriptions.d.ts.map

package/dist/schemas/extensions/x-enum-descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-enum-descriptions.d.ts","sourceRoot":"","sources":["../../../src/schemas/extensions/x-enum-descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAA"}

package/dist/schemas/extensions/x-enum-descriptions.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+/**
+ * x-enumDescriptions
+ *
+ * Maps enum values to their descriptions. Each key should correspond to
+ * an enum value, and the value is the description for that enum value.
+ *
+ * Example:
+ * x-enumDescriptions:
+ *   missing_features: "Missing features"
+ *   too_expensive: "Too expensive"
+ *   unused: "Unused"
+ *   other: "Other"
+ */
+const XEnumDescriptionsSchema = z.object({
+    'x-enumDescriptions': z.record(z.string(), z.string()).catch({}),
+});
+
+export { XEnumDescriptionsSchema };

package/dist/schemas/extensions/x-internal.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const XInternalSchema: z.ZodObject<{
+    'x-internal': z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    'x-internal'?: boolean | undefined;
+}, {
+    'x-internal'?: unknown;
+}>;
+//# sourceMappingURL=x-internal.d.ts.map

package/dist/schemas/extensions/x-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-internal.d.ts","sourceRoot":"","sources":["../../../src/schemas/extensions/x-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,eAAe;;;;;;EAE1B,CAAA"}

package/dist/schemas/extensions/x-internal.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+const XInternalSchema = z.object({
+    'x-internal': z.boolean().optional().catch(undefined),
+});
+
+export { XInternalSchema };