@scalar/openapi-types 0.1.8 → 0.2.0

package/dist/schemas/3.1/unprocessed/security-scheme-object.d.ts

@@ -0,0 +1,590 @@
+/**
+ * Security Scheme Object
+ *
+ * Defines a security scheme that can be used by the operations.
+ *
+ * Supported schemes are HTTP authentication, an API key (either as a header, a cookie parameter or as a query
+ * parameter), mutual TLS (use of a client certificate), OAuth2's common flows (implicit, password, client credentials
+ * and authorization code) as defined in RFC6749, and [[OpenID-Connect-Core]]. Please note that as of 2020, the implicit
+ * flow is about to be deprecated by OAuth 2.0 Security Best Current Practice. Recommended for most use cases is
+ * Authorization Code Grant flow with PKCE.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#security-scheme-object
+ */
+export declare const SecuritySchemeObjectSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"apiKey">;
+    name: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    in: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["query", "header", "cookie"]>>>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    name: string;
+    in: "query" | "header" | "cookie";
+    type: "apiKey";
+    description?: string | undefined;
+}, {
+    type: "apiKey";
+    description?: string | undefined;
+    name?: string | undefined;
+    in?: unknown;
+}>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"http">;
+    scheme: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodPipeline<import("zod").ZodString, import("zod").ZodEnum<["basic", "bearer"]>>>>;
+    bearerFormat: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodLiteral<"JWT">, import("zod").ZodLiteral<"bearer">, import("zod").ZodString]>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "http";
+    scheme: "basic" | "bearer";
+    description?: string | undefined;
+    bearerFormat?: string | undefined;
+}, {
+    type: "http";
+    description?: string | undefined;
+    scheme?: string | undefined;
+    bearerFormat?: string | undefined;
+}>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"mutualTLS">;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "mutualTLS";
+    description?: string | undefined;
+}, {
+    type: "mutualTLS";
+    description?: string | undefined;
+}>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"oauth2">;
+    flows: import("zod").ZodObject<{
+        implicit: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"implicit">>;
+            authorizationUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+        }>>>;
+        password: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"password">>;
+            tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        }>>>;
+        clientCredentials: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"clientCredentials">>;
+            tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        }>>>;
+        authorizationCode: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"authorizationCode">>;
+            authorizationUrl: import("zod").ZodDefault<import("zod").ZodString>;
+            tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+            tokenUrl?: string | undefined;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        implicit?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+    }, {
+        implicit?: {
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+            tokenUrl?: string | undefined;
+        } | undefined;
+    }>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "oauth2";
+    flows: {
+        implicit?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+    };
+    description?: string | undefined;
+}, {
+    type: "oauth2";
+    flows: {
+        implicit?: {
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+            tokenUrl?: string | undefined;
+        } | undefined;
+    };
+    description?: string | undefined;
+}>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"openIdConnect">;
+    openIdConnectUrl: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "openIdConnect";
+    openIdConnectUrl: string;
+    description?: string | undefined;
+}, {
+    type: "openIdConnect";
+    description?: string | undefined;
+    openIdConnectUrl?: string | undefined;
+}>]>;
+export declare const ApiKeyInValues: readonly ["query", "header", "cookie"];
+export declare const ApiKeySchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"apiKey">;
+    name: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    in: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["query", "header", "cookie"]>>>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    name: string;
+    in: "query" | "header" | "cookie";
+    type: "apiKey";
+    description?: string | undefined;
+}, {
+    type: "apiKey";
+    description?: string | undefined;
+    name?: string | undefined;
+    in?: unknown;
+}>;
+export declare const HttpSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"http">;
+    scheme: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodPipeline<import("zod").ZodString, import("zod").ZodEnum<["basic", "bearer"]>>>>;
+    bearerFormat: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodLiteral<"JWT">, import("zod").ZodLiteral<"bearer">, import("zod").ZodString]>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "http";
+    scheme: "basic" | "bearer";
+    description?: string | undefined;
+    bearerFormat?: string | undefined;
+}, {
+    type: "http";
+    description?: string | undefined;
+    scheme?: string | undefined;
+    bearerFormat?: string | undefined;
+}>;
+export declare const MutualTlsSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"mutualTLS">;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "mutualTLS";
+    description?: string | undefined;
+}, {
+    type: "mutualTLS";
+    description?: string | undefined;
+}>;
+export declare const OpenIdConnectSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"openIdConnect">;
+    openIdConnectUrl: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "openIdConnect";
+    openIdConnectUrl: string;
+    description?: string | undefined;
+}, {
+    type: "openIdConnect";
+    description?: string | undefined;
+    openIdConnectUrl?: string | undefined;
+}>;
+export declare const OAuthFlowsObjectSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+}, {
+    type: import("zod").ZodLiteral<"oauth2">;
+    flows: import("zod").ZodObject<{
+        implicit: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"implicit">>;
+            authorizationUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+        }>>>;
+        password: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"password">>;
+            tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        }>>>;
+        clientCredentials: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"clientCredentials">>;
+            tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        }>>>;
+        authorizationCode: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+        }, {
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"authorizationCode">>;
+            authorizationUrl: import("zod").ZodDefault<import("zod").ZodString>;
+            tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+        }>, "strip", import("zod").ZodTypeAny, {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+        }, {
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+            tokenUrl?: string | undefined;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        implicit?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+    }, {
+        implicit?: {
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+            tokenUrl?: string | undefined;
+        } | undefined;
+    }>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "oauth2";
+    flows: {
+        implicit?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            scopes: Record<string, string | undefined>;
+            tokenUrl: string;
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            scopes: Record<string, string | undefined>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+        } | undefined;
+    };
+    description?: string | undefined;
+}, {
+    type: "oauth2";
+    flows: {
+        implicit?: {
+            type?: "implicit" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+        } | undefined;
+        password?: {
+            type?: "password" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        clientCredentials?: {
+            type?: "clientCredentials" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            tokenUrl?: string | undefined;
+        } | undefined;
+        authorizationCode?: {
+            type?: "authorizationCode" | undefined;
+            refreshUrl?: string | undefined;
+            scopes?: unknown;
+            authorizationUrl?: string | undefined;
+            tokenUrl?: string | undefined;
+        } | undefined;
+    };
+    description?: string | undefined;
+}>;
+export declare const OAuthFlowObjectSchema: import("zod").ZodObject<{
+    refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    scopes: Record<string, string | undefined>;
+    refreshUrl?: string | undefined;
+}, {
+    refreshUrl?: string | undefined;
+    scopes?: unknown;
+}>;
+export declare const AuthorizationCodeFlowSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+}, {
+    type: import("zod").ZodOptional<import("zod").ZodLiteral<"authorizationCode">>;
+    authorizationUrl: import("zod").ZodDefault<import("zod").ZodString>;
+    tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+}>, "strip", import("zod").ZodTypeAny, {
+    scopes: Record<string, string | undefined>;
+    authorizationUrl: string;
+    tokenUrl: string;
+    type?: "authorizationCode" | undefined;
+    refreshUrl?: string | undefined;
+}, {
+    type?: "authorizationCode" | undefined;
+    refreshUrl?: string | undefined;
+    scopes?: unknown;
+    authorizationUrl?: string | undefined;
+    tokenUrl?: string | undefined;
+}>;
+export declare const ClientCredentialsFlowSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+}, {
+    type: import("zod").ZodOptional<import("zod").ZodLiteral<"clientCredentials">>;
+    tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+}>, "strip", import("zod").ZodTypeAny, {
+    scopes: Record<string, string | undefined>;
+    tokenUrl: string;
+    type?: "clientCredentials" | undefined;
+    refreshUrl?: string | undefined;
+}, {
+    type?: "clientCredentials" | undefined;
+    refreshUrl?: string | undefined;
+    scopes?: unknown;
+    tokenUrl?: string | undefined;
+}>;
+export declare const ImplicitFlowSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+}, {
+    type: import("zod").ZodOptional<import("zod").ZodLiteral<"implicit">>;
+    authorizationUrl: import("zod").ZodDefault<import("zod").ZodString>;
+}>, "strip", import("zod").ZodTypeAny, {
+    scopes: Record<string, string | undefined>;
+    authorizationUrl: string;
+    type?: "implicit" | undefined;
+    refreshUrl?: string | undefined;
+}, {
+    type?: "implicit" | undefined;
+    refreshUrl?: string | undefined;
+    scopes?: unknown;
+    authorizationUrl?: string | undefined;
+}>;
+export declare const PasswordFlowSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    refreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    scopes: import("zod").ZodCatch<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>>>;
+}, {
+    type: import("zod").ZodOptional<import("zod").ZodLiteral<"password">>;
+    tokenUrl: import("zod").ZodDefault<import("zod").ZodString>;
+}>, "strip", import("zod").ZodTypeAny, {
+    scopes: Record<string, string | undefined>;
+    tokenUrl: string;
+    type?: "password" | undefined;
+    refreshUrl?: string | undefined;
+}, {
+    type?: "password" | undefined;
+    refreshUrl?: string | undefined;
+    scopes?: unknown;
+    tokenUrl?: string | undefined;
+}>;
+//# sourceMappingURL=security-scheme-object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"security-scheme-object.d.ts","sourceRoot":"","sources":["../../../../src/schemas/3.1/unprocessed/security-scheme-object.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAqC,CAAA;AAE5E,eAAO,MAAM,cAAc,wCAAyB,CAAA;AACpD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAAuB,CAAA;AAChD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;EAAqB,CAAA;AAC5C,eAAO,MAAM,eAAe;;;;;;;;;;EAA0B,CAAA;AACtD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;EAA8B,CAAA;AAE9D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AACpE,eAAO,MAAM,qBAAqB;;;;;;;;;EAAgC,CAAA;AAClE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;EAAsC,CAAA;AAC9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAAsC,CAAA;AAC9E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;EAA6B,CAAA;AAC5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;EAA6B,CAAA"}

package/dist/schemas/3.1/unprocessed/security-scheme-object.js

@@ -0,0 +1,29 @@
+import { SecuritySchemeObjectSchema as SecuritySchemeObjectSchema$1, ApiKeyInValues as ApiKeyInValues$1, ApiKeySchema as ApiKeySchema$1, HttpSchema as HttpSchema$1, MutualTlsSchema as MutualTlsSchema$1, OpenIdConnectSchema as OpenIdConnectSchema$1, OAuthFlowsObjectSchema as OAuthFlowsObjectSchema$1, OAuthFlowObjectSchema as OAuthFlowObjectSchema$1, AuthorizationCodeFlowSchema as AuthorizationCodeFlowSchema$1, ClientCredentialsFlowSchema as ClientCredentialsFlowSchema$1, ImplicitFlowSchema as ImplicitFlowSchema$1, PasswordFlowSchema as PasswordFlowSchema$1 } from '../processed/security-scheme-object.js';
+
+/**
+ * Security Scheme Object
+ *
+ * Defines a security scheme that can be used by the operations.
+ *
+ * Supported schemes are HTTP authentication, an API key (either as a header, a cookie parameter or as a query
+ * parameter), mutual TLS (use of a client certificate), OAuth2's common flows (implicit, password, client credentials
+ * and authorization code) as defined in RFC6749, and [[OpenID-Connect-Core]]. Please note that as of 2020, the implicit
+ * flow is about to be deprecated by OAuth 2.0 Security Best Current Practice. Recommended for most use cases is
+ * Authorization Code Grant flow with PKCE.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#security-scheme-object
+ */
+const SecuritySchemeObjectSchema = SecuritySchemeObjectSchema$1;
+const ApiKeyInValues = ApiKeyInValues$1;
+const ApiKeySchema = ApiKeySchema$1;
+const HttpSchema = HttpSchema$1;
+const MutualTlsSchema = MutualTlsSchema$1;
+const OpenIdConnectSchema = OpenIdConnectSchema$1;
+const OAuthFlowsObjectSchema = OAuthFlowsObjectSchema$1;
+const OAuthFlowObjectSchema = OAuthFlowObjectSchema$1;
+const AuthorizationCodeFlowSchema = AuthorizationCodeFlowSchema$1;
+const ClientCredentialsFlowSchema = ClientCredentialsFlowSchema$1;
+const ImplicitFlowSchema = ImplicitFlowSchema$1;
+const PasswordFlowSchema = PasswordFlowSchema$1;
+
+export { ApiKeyInValues, ApiKeySchema, AuthorizationCodeFlowSchema, ClientCredentialsFlowSchema, HttpSchema, ImplicitFlowSchema, MutualTlsSchema, OAuthFlowObjectSchema, OAuthFlowsObjectSchema, OpenIdConnectSchema, PasswordFlowSchema, SecuritySchemeObjectSchema };

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

@@ -0,0 +1,41 @@
+/**
+ * Server Object
+ *
+ * An object representing a Server.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#server-object
+ */
+export declare const ServerObjectSchema: import("zod").ZodObject<{
+    url: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    variables: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, 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;
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    description?: string | undefined;
+    variables?: Record<string, {
+        description?: string | undefined;
+        default?: string | undefined;
+        enum?: string[] | undefined;
+    }> | undefined;
+}, {
+    url: string;
+    description?: string | undefined;
+    variables?: Record<string, {
+        description?: string | undefined;
+        default?: string | undefined;
+        enum?: string[] | undefined;
+    }> | undefined;
+}>;
+//# sourceMappingURL=server-object.d.ts.map

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

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