@scalar/oas-utils 0.2.43 → 0.2.45

package/dist/entities/spec/collection.d.ts

@@ -0,0 +1,489 @@
+import { z } from 'zod';
+export declare const extendedCollectionSchema: z.ZodObject<{
+    uid: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** A list of security schemes UIDs associated with the collection */
+    securitySchemes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The currently selected server */
+    selectedServerUid: z.ZodDefault<z.ZodString>;
+    /** UIDs which refer to servers on the workspace base */
+    servers: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** Request UIDs associated with a collection */
+    requests: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** Tag UIDs associated with the collection */
+    tags: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** List of requests without tags and top level tag "folders" */
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /**
+     * Map of security schemas to their value sets
+     *
+     * For each selected security schema we should have an entry here
+     * The entry will contain the secret values (but not the schema definition)
+     */
+    auth: z.ZodDefault<z.ZodRecord<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"apiKey">>;
+        name: z.ZodDefault<z.ZodString>;
+        value: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "apiKey";
+        value: string;
+        name: string;
+    }, {
+        type?: "apiKey" | undefined;
+        value?: string | undefined;
+        name?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"http">>;
+        username: z.ZodDefault<z.ZodString>;
+        password: z.ZodDefault<z.ZodString>;
+        token: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "http";
+        username: string;
+        password: string;
+        token: string;
+    }, {
+        type?: "http" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-implicit">>;
+        token: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-implicit";
+        token: string;
+    }, {
+        type?: "oauth-implicit" | undefined;
+        token?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-password">>;
+        token: z.ZodDefault<z.ZodString>;
+        username: z.ZodDefault<z.ZodString>;
+        password: z.ZodDefault<z.ZodString>;
+        clientSecret: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-password";
+        username: string;
+        password: string;
+        token: string;
+        clientSecret: string;
+    }, {
+        type?: "oauth-password" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-clientCredentials">>;
+        token: z.ZodDefault<z.ZodString>;
+        clientSecret: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-clientCredentials";
+        token: string;
+        clientSecret: string;
+    }, {
+        type?: "oauth-clientCredentials" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-authorizationCode">>;
+        token: z.ZodDefault<z.ZodString>;
+        clientSecret: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-authorizationCode";
+        token: string;
+        clientSecret: string;
+    }, {
+        type?: "oauth-authorizationCode" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }>]>>>;
+}, "strip", z.ZodTypeAny, {
+    uid: string;
+    children: string[];
+    securitySchemes: string[];
+    selectedServerUid: string;
+    servers: string[];
+    requests: string[];
+    tags: string[];
+    auth: Record<string, {
+        type: "apiKey";
+        value: string;
+        name: string;
+    } | {
+        type: "http";
+        username: string;
+        password: string;
+        token: string;
+    } | {
+        type: "oauth-implicit";
+        token: string;
+    } | {
+        type: "oauth-password";
+        username: string;
+        password: string;
+        token: string;
+        clientSecret: string;
+    } | {
+        type: "oauth-clientCredentials";
+        token: string;
+        clientSecret: string;
+    } | {
+        type: "oauth-authorizationCode";
+        token: string;
+        clientSecret: string;
+    }>;
+}, {
+    uid?: string | undefined;
+    children?: (string | undefined)[] | undefined;
+    securitySchemes?: string[] | undefined;
+    selectedServerUid?: string | undefined;
+    servers?: (string | undefined)[] | undefined;
+    requests?: (string | undefined)[] | undefined;
+    tags?: (string | undefined)[] | undefined;
+    auth?: Record<string | undefined, {
+        type?: "apiKey" | undefined;
+        value?: string | undefined;
+        name?: string | undefined;
+    } | {
+        type?: "http" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+    } | {
+        type?: "oauth-implicit" | undefined;
+        token?: string | undefined;
+    } | {
+        type?: "oauth-password" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    } | {
+        type?: "oauth-clientCredentials" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    } | {
+        type?: "oauth-authorizationCode" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }> | undefined;
+}>;
+export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
+    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"collection">>>;
+    openapi: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<"3.0.0">, z.ZodLiteral<"3.1.0">, z.ZodLiteral<"4.0.0">]>>>;
+    jsonSchemaDialect: z.ZodOptional<z.ZodString>;
+    info: z.ZodOptional<z.ZodObject<{
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        summary: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        termsOfService: z.ZodOptional<z.ZodString>;
+        contact: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string | undefined;
+            url?: string | undefined;
+            email?: string | undefined;
+        }, {
+            name?: string | undefined;
+            url?: string | undefined;
+            email?: string | undefined;
+        }>>;
+        license: z.ZodOptional<z.ZodObject<{
+            name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            identifier: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            identifier?: string | undefined;
+            url?: string | undefined;
+        }, {
+            name?: string | undefined;
+            identifier?: string | undefined;
+            url?: string | undefined;
+        }>>;
+        version: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        version: string;
+        description?: string | undefined;
+        summary?: string | undefined;
+        termsOfService?: string | undefined;
+        contact?: {
+            name?: string | undefined;
+            url?: string | undefined;
+            email?: string | undefined;
+        } | undefined;
+        license?: {
+            name: string;
+            identifier?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+    }, {
+        description?: string | undefined;
+        title?: string | undefined;
+        summary?: string | undefined;
+        termsOfService?: string | undefined;
+        contact?: {
+            name?: string | undefined;
+            url?: string | undefined;
+            email?: string | undefined;
+        } | undefined;
+        license?: {
+            name?: string | undefined;
+            identifier?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+        version?: string | undefined;
+    }>>;
+    /**
+     * A declaration of which security mechanisms can be used across the API. The list of
+     * values includes alternative security requirement objects that can be used. Only
+     * one of the security requirement objects need to be satisfied to authorize a request.
+     * Individual operations can override this definition. To make security optional, an empty
+     * security requirement ({}) can be included in the array.
+     */
+    security: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>>, "many">>>;
+    externalDocs: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        url: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+    }, {
+        description?: string | undefined;
+        url?: string | undefined;
+    }>>;
+    /** TODO: Type these */
+    components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** TODO: Type these */
+    webhooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, {
+    uid: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** A list of security schemes UIDs associated with the collection */
+    securitySchemes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The currently selected server */
+    selectedServerUid: z.ZodDefault<z.ZodString>;
+    /** UIDs which refer to servers on the workspace base */
+    servers: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** Request UIDs associated with a collection */
+    requests: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** Tag UIDs associated with the collection */
+    tags: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** List of requests without tags and top level tag "folders" */
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /**
+     * Map of security schemas to their value sets
+     *
+     * For each selected security schema we should have an entry here
+     * The entry will contain the secret values (but not the schema definition)
+     */
+    auth: z.ZodDefault<z.ZodRecord<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"apiKey">>;
+        name: z.ZodDefault<z.ZodString>;
+        value: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "apiKey";
+        value: string;
+        name: string;
+    }, {
+        type?: "apiKey" | undefined;
+        value?: string | undefined;
+        name?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"http">>;
+        username: z.ZodDefault<z.ZodString>;
+        password: z.ZodDefault<z.ZodString>;
+        token: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "http";
+        username: string;
+        password: string;
+        token: string;
+    }, {
+        type?: "http" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-implicit">>;
+        token: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-implicit";
+        token: string;
+    }, {
+        type?: "oauth-implicit" | undefined;
+        token?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-password">>;
+        token: z.ZodDefault<z.ZodString>;
+        username: z.ZodDefault<z.ZodString>;
+        password: z.ZodDefault<z.ZodString>;
+        clientSecret: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-password";
+        username: string;
+        password: string;
+        token: string;
+        clientSecret: string;
+    }, {
+        type?: "oauth-password" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-clientCredentials">>;
+        token: z.ZodDefault<z.ZodString>;
+        clientSecret: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-clientCredentials";
+        token: string;
+        clientSecret: string;
+    }, {
+        type?: "oauth-clientCredentials" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodDefault<z.ZodLiteral<"oauth-authorizationCode">>;
+        token: z.ZodDefault<z.ZodString>;
+        clientSecret: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth-authorizationCode";
+        token: string;
+        clientSecret: string;
+    }, {
+        type?: "oauth-authorizationCode" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }>]>>>;
+}>, "strip", z.ZodTypeAny, {
+    type: "collection";
+    uid: string;
+    children: string[];
+    openapi: string;
+    security: Record<string, string[]>[];
+    securitySchemes: string[];
+    selectedServerUid: string;
+    servers: string[];
+    requests: string[];
+    tags: string[];
+    auth: Record<string, {
+        type: "apiKey";
+        value: string;
+        name: string;
+    } | {
+        type: "http";
+        username: string;
+        password: string;
+        token: string;
+    } | {
+        type: "oauth-implicit";
+        token: string;
+    } | {
+        type: "oauth-password";
+        username: string;
+        password: string;
+        token: string;
+        clientSecret: string;
+    } | {
+        type: "oauth-clientCredentials";
+        token: string;
+        clientSecret: string;
+    } | {
+        type: "oauth-authorizationCode";
+        token: string;
+        clientSecret: string;
+    }>;
+    externalDocs?: {
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    jsonSchemaDialect?: string | undefined;
+    info?: {
+        title: string;
+        version: string;
+        description?: string | undefined;
+        summary?: string | undefined;
+        termsOfService?: string | undefined;
+        contact?: {
+            name?: string | undefined;
+            url?: string | undefined;
+            email?: string | undefined;
+        } | undefined;
+        license?: {
+            name: string;
+            identifier?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+    } | undefined;
+    components?: Record<string, unknown> | undefined;
+    webhooks?: Record<string, unknown> | undefined;
+}, {
+    type?: "collection" | undefined;
+    uid?: string | undefined;
+    externalDocs?: {
+        description?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    children?: (string | undefined)[] | undefined;
+    openapi?: string | undefined;
+    jsonSchemaDialect?: string | undefined;
+    info?: {
+        description?: string | undefined;
+        title?: string | undefined;
+        summary?: string | undefined;
+        termsOfService?: string | undefined;
+        contact?: {
+            name?: string | undefined;
+            url?: string | undefined;
+            email?: string | undefined;
+        } | undefined;
+        license?: {
+            name?: string | undefined;
+            identifier?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+        version?: string | undefined;
+    } | undefined;
+    security?: Record<string, string[] | undefined>[] | undefined;
+    components?: Record<string, unknown> | undefined;
+    webhooks?: Record<string, unknown> | undefined;
+    securitySchemes?: string[] | undefined;
+    selectedServerUid?: string | undefined;
+    servers?: (string | undefined)[] | undefined;
+    requests?: (string | undefined)[] | undefined;
+    tags?: (string | undefined)[] | undefined;
+    auth?: Record<string | undefined, {
+        type?: "apiKey" | undefined;
+        value?: string | undefined;
+        name?: string | undefined;
+    } | {
+        type?: "http" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+    } | {
+        type?: "oauth-implicit" | undefined;
+        token?: string | undefined;
+    } | {
+        type?: "oauth-password" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    } | {
+        type?: "oauth-clientCredentials" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    } | {
+        type?: "oauth-authorizationCode" | undefined;
+        token?: string | undefined;
+        clientSecret?: string | undefined;
+    }> | undefined;
+}>;
+export type Collection = z.infer<typeof collectionSchema>;
+export type CollectionPayload = z.input<typeof collectionSchema>;
+//# sourceMappingURL=collection.d.ts.map

package/dist/entities/spec/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuCvB,eAAO,MAAM,wBAAwB;;IAEnC,qEAAqE;;IAErE,oCAAoC;;IAEpC,wDAAwD;;IAExD,gDAAgD;;IAEhD,8CAA8C;;IAE9C,gEAAgE;;IAEhE;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA5C3B;;;;;;OAMG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;IAYvB,qEAAqE;;IAErE,oCAAoC;;IAEpC,wDAAwD;;IAExD,gDAAgD;;IAEhD,8CAA8C;;IAE9C,gEAAgE;;IAEhE;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMJ,CAAA;AACD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/entities/spec/collection.js

@@ -0,0 +1,63 @@
+import { oasSecurityRequirementSchema, securitySchemeExampleValueSchema } from './security.js';
+import { z } from 'zod';
+import { oasInfoSchema, oasExternalDocumentationSchema } from './spec-objects.js';
+import { nanoidSchema } from '../shared/utility.js';
+
+const oasCollectionSchema = z.object({
+    type: z.literal('collection').optional().default('collection'),
+    openapi: z
+        .union([
+        z.string(),
+        z.literal('3.0.0'),
+        z.literal('3.1.0'),
+        z.literal('4.0.0'),
+    ])
+        .optional()
+        .default('3.1.0'),
+    jsonSchemaDialect: z.string().optional(),
+    info: oasInfoSchema.optional(),
+    /**
+     * A declaration of which security mechanisms can be used across the API. The list of
+     * values includes alternative security requirement objects that can be used. Only
+     * one of the security requirement objects need to be satisfied to authorize a request.
+     * Individual operations can override this definition. To make security optional, an empty
+     * security requirement ({}) can be included in the array.
+     */
+    security: z.array(oasSecurityRequirementSchema).optional().default([]),
+    externalDocs: oasExternalDocumentationSchema.optional(),
+    /** TODO: Type these */
+    components: z.record(z.string(), z.unknown()).optional(),
+    /** TODO: Type these */
+    webhooks: z.record(z.string(), z.unknown()).optional(),
+    // These properties will be stripped out and mapped back as id lists
+    // servers
+    // paths/**
+    // servers
+    // tags
+    // security
+});
+const extendedCollectionSchema = z.object({
+    uid: nanoidSchema,
+    /** A list of security schemes UIDs associated with the collection */
+    securitySchemes: z.string().array().default([]),
+    /** The currently selected server */
+    selectedServerUid: z.string().default(''),
+    /** UIDs which refer to servers on the workspace base */
+    servers: nanoidSchema.array().default([]),
+    /** Request UIDs associated with a collection */
+    requests: nanoidSchema.array().default([]),
+    /** Tag UIDs associated with the collection */
+    tags: nanoidSchema.array().default([]),
+    /** List of requests without tags and top level tag "folders" */
+    children: nanoidSchema.array().default([]),
+    /**
+     * Map of security schemas to their value sets
+     *
+     * For each selected security schema we should have an entry here
+     * The entry will contain the secret values (but not the schema definition)
+     */
+    auth: z.record(nanoidSchema, securitySchemeExampleValueSchema).default({}),
+});
+const collectionSchema = oasCollectionSchema.merge(extendedCollectionSchema);
+
+export { collectionSchema, extendedCollectionSchema };

package/dist/entities/spec/index.d.ts

@@ -0,0 +1,10 @@
+export * from './collection.js';
+export * from './server.js';
+export * from './requests.js';
+export * from './request-examples.js';
+export * from './spec-objects.js';
+export * from './parameters.js';
+export * from './security.js';
+type FetchRequest = Request;
+export type { FetchRequest };
+//# sourceMappingURL=index.d.ts.map

package/dist/entities/spec/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAE1B,KAAK,YAAY,GAAG,OAAO,CAAA;AAC3B,YAAY,EAAE,YAAY,EAAE,CAAA"}

package/dist/entities/spec/index.js

@@ -0,0 +1,7 @@
+export { collectionSchema, extendedCollectionSchema } from './collection.js';
+export { oasServerSchema, oasServerVariableSchema, serverSchema } from './server.js';
+export { oasRequestSchema, requestMethods, requestSchema } from './requests.js';
+export { createExampleFromRequest, createParamInstance, exampleRequestBodyEncoding, exampleRequestBodySchema, requestExampleParametersSchema, requestExampleSchema } from './request-examples.js';
+export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, oasTagSchema, tagSchema, xScalarNestedSchema } from './spec-objects.js';
+export { oasParameterSchema, parameterStyleSchema, parameterTypeSchema } from './parameters.js';
+export { authExampleFromSchema, oasSecurityRequirementSchema, oasSecuritySchemeSchema, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeApiKeyIn, securitySchemeExampleValueSchema, securitySchemeSchema } from './security.js';

package/dist/entities/spec/parameters.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const parameterTypeSchema: z.ZodEnum<["path", "query", "header", "cookie"]>;
+export type ParamType = z.infer<typeof parameterTypeSchema>;
+export declare const parameterStyleSchema: z.ZodEnum<["matrix", "simple", "form", "label", "spaceDelimited", "pipeDelimited", "deepObject"]>;
+export type ParameterStyle = z.infer<typeof parameterStyleSchema>;
+/**
+ * OpenAPI compliant parameters object
+ */
+export declare const oasParameterSchema: z.ZodObject<{
+    in: z.ZodEnum<["path", "query", "header", "cookie"]>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    /** Defaulted to false */
+    required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Defaulted to false */
+    deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    schema: z.ZodOptional<z.ZodUnknown>;
+    content: z.ZodOptional<z.ZodUnknown>;
+    /** Defaulted according to @url https://spec.openapis.org/oas/v3.1.0#parameter-object */
+    style: z.ZodOptional<z.ZodEnum<["matrix", "simple", "form", "label", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+}, "strip", z.ZodTypeAny, {
+    required: boolean;
+    name: string;
+    in: "path" | "query" | "header" | "cookie";
+    deprecated: boolean;
+    description?: string | undefined;
+    schema?: unknown;
+    content?: unknown;
+    style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+}, {
+    name: string;
+    in: "path" | "query" | "header" | "cookie";
+    required?: boolean | undefined;
+    description?: string | undefined;
+    deprecated?: boolean | undefined;
+    schema?: unknown;
+    content?: unknown;
+    style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+}>;
+export type RequestParameter = z.infer<typeof oasParameterSchema>;
+export type RequestParameterPayload = z.input<typeof oasParameterSchema>;
+//# sourceMappingURL=parameters.d.ts.map

package/dist/entities/spec/parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/parameters.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,eAAO,MAAM,mBAAmB,kDAAgD,CAAA;AAChF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE3D,eAAO,MAAM,oBAAoB,mGAQ/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;IAI7B,yBAAyB;;IAEzB,yBAAyB;;;;IAIzB,wFAAwF;;;;;;;;;;;;;;;;;;;;EAEjD,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACjE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/entities/spec/parameters.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+const parameterTypeSchema = z.enum(['path', 'query', 'header', 'cookie']);
+const parameterStyleSchema = z.enum([
+    'matrix',
+    'simple',
+    'form',
+    'label',
+    'spaceDelimited',
+    'pipeDelimited',
+    'deepObject',
+]);
+/**
+ * OpenAPI compliant parameters object
+ */
+const oasParameterSchema = z.object({
+    in: parameterTypeSchema,
+    name: z.string(),
+    description: z.string().optional(),
+    /** Defaulted to false */
+    required: z.boolean().optional().default(false),
+    /** Defaulted to false */
+    deprecated: z.boolean().optional().default(false),
+    schema: z.unknown().optional(),
+    content: z.unknown().optional(),
+    /** Defaulted according to @url https://spec.openapis.org/oas/v3.1.0#parameter-object */
+    style: parameterStyleSchema.optional(),
+});
+
+export { oasParameterSchema, parameterStyleSchema, parameterTypeSchema };