@scalar/oas-utils 0.2.102 → 0.2.104

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @scalar/oas-utils
 
+## 0.2.104
+
+### Patch Changes
+
+- f500435: chore: stricter TypeScript configuration
+- da5cf08: fix: add security requirements for operations
+- b5727ef: feat: allow pre-selecting multiple and complex auth
+- 4de3124: feat: improve parameter zod schema
+- 34e6f52: feat: upgrade to stricter tsconfig
+- Updated dependencies [f500435]
+- Updated dependencies [b5727ef]
+- Updated dependencies [34e6f52]
+- Updated dependencies [f2b082a]
+  - @scalar/types@0.0.32
+  - @scalar/themes@0.9.66
+
+## 0.2.103
+
+### Patch Changes
+
+- 0f5df68: chore: refactored send request with extensive test suite
+- 937f791: chore: alias request to operation
+- Updated dependencies [a30e7cc]
+  - @scalar/types@0.0.31
+  - @scalar/themes@0.9.65
+
 ## 0.2.102
 
 ### Patch Changes

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

@@ -8,4 +8,5 @@ export * from './security.js';
 export * from './x-scalar-environments.js';
 type FetchRequest = Request;
 export type { FetchRequest };
+export { type Operation, type OperationPayload, operationSchema, } from './operation.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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;AAC1B,cAAc,yBAAyB,CAAA;AAEvC,KAAK,YAAY,GAAG,OAAO,CAAA;AAC3B,YAAY,EAAE,YAAY,EAAE,CAAA"}
+{"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;AAC1B,cAAc,yBAAyB,CAAA;AAEvC,KAAK,YAAY,GAAG,OAAO,CAAA;AAC3B,YAAY,EAAE,YAAY,EAAE,CAAA;AAE5B,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAA"}

package/dist/entities/spec/index.js

@@ -1,8 +1,9 @@
 export { collectionSchema, extendedCollectionSchema, oasCollectionSchema } from './collection.js';
 export { oasServerSchema, oasServerVariableSchema, serverSchema } from './server.js';
 export { oasRequestSchema, requestMethods, requestSchema } from './requests.js';
-export { convertExampleToXScalar, createExampleFromRequest, createParamInstance, exampleBodyMime, exampleRequestBodyEncoding, exampleRequestBodySchema, requestExampleParametersSchema, requestExampleSchema, xScalarExampleBodySchema, xScalarExampleSchema, xScalarFileValueSchema, xScalarFormDataValue } from './request-examples.js';
+export { convertExampleToXScalar, createExampleFromRequest, createParamInstance, exampleBodyMime, exampleRequestBodyEncoding, exampleRequestBodySchema, parameterArrayToObject, requestExampleParametersSchema, requestExampleSchema, xScalarExampleBodySchema, xScalarExampleSchema, xScalarFileValueSchema, xScalarFormDataValue } from './request-examples.js';
 export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, oasTagSchema, tagSchema, xScalarNestedSchema } from './spec-objects.js';
 export { oasParameterSchema, parameterStyleSchema, parameterTypeSchema } from './parameters.js';
 export { oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeApiKeyIn, securitySchemeSchema } from './security.js';
 export { xScalarEnvVarSchema, xScalarEnvironmentSchema, xScalarEnvironmentsSchema } from './x-scalar-environments.js';
+export { operationSchema } from './operation.js';

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

@@ -0,0 +1,243 @@
+/**
+ * Aliases Request to Operation which is closer to the spec,
+ * also will not conflict with the builtin Request class
+ */
+import { type RequestPayload, type Request as RequestType } from './requests.js';
+export type Operation = RequestType;
+export type OperationPayload = RequestPayload;
+export declare const operationSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<Omit<{
+    tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    summary: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    operationId: import("zod").ZodOptional<import("zod").ZodString>;
+    security: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>>, "many">>;
+    requestBody: import("zod").ZodOptional<import("zod").ZodAny>;
+    parameters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        in: import("zod").ZodEnum<["path", "query", "header", "cookie"]>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        required: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        deprecated: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        schema: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        content: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        style: import("zod").ZodOptional<import("zod").ZodEnum<["matrix", "simple", "form", "label", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+        example: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        examples: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            value: import("zod").ZodUnknown;
+            summary: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            value?: unknown;
+            summary?: string | undefined;
+        }, {
+            value?: unknown;
+            summary?: string | undefined;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        required: boolean;
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        deprecated: boolean;
+        description?: string | undefined;
+        example?: unknown;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        examples?: Record<string, {
+            value?: unknown;
+            summary?: string | undefined;
+        }> | undefined;
+    }, {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        required?: boolean | undefined;
+        description?: string | undefined;
+        example?: unknown;
+        deprecated?: boolean | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        examples?: Record<string, {
+            value?: unknown;
+            summary?: string | undefined;
+        }> | undefined;
+    }>, "many">>;
+    externalDocs: import("zod").ZodOptional<import("zod").ZodObject<{
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        url: import("zod").ZodDefault<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+    }, {
+        description?: string | undefined;
+        url?: string | undefined;
+    }>>;
+    deprecated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    responses: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    'x-scalar-examples': import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        body: import("zod").ZodOptional<import("zod").ZodObject<{
+            encoding: import("zod").ZodEnum<["application/json", "text/plain", "text/html", "application/javascript", "application/xml", "application/yaml", "application/edn", "application/octet-stream", "application/x-www-form-urlencoded", "multipart/form-data", "binary"]>;
+            content: import("zod").ZodUnion<[import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>, import("zod").ZodString]>;
+            file: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+                url: import("zod").ZodString;
+                base64: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                url: string;
+                base64?: string | undefined;
+            }, {
+                url: string;
+                base64?: string | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            content: string | Record<string, any>;
+            encoding: "application/json" | "text/plain" | "text/html" | "application/javascript" | "application/xml" | "application/yaml" | "application/edn" | "application/octet-stream" | "application/x-www-form-urlencoded" | "multipart/form-data" | "binary";
+            file?: {
+                url: string;
+                base64?: string | undefined;
+            } | null | undefined;
+        }, {
+            content: string | Record<string, any>;
+            encoding: "application/json" | "text/plain" | "text/html" | "application/javascript" | "application/xml" | "application/yaml" | "application/edn" | "application/octet-stream" | "application/x-www-form-urlencoded" | "multipart/form-data" | "binary";
+            file?: {
+                url: string;
+                base64?: string | undefined;
+            } | null | undefined;
+        }>>;
+        parameters: import("zod").ZodObject<{
+            path: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            query: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            cookies: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            path?: Record<string, string> | undefined;
+            cookies?: Record<string, string> | undefined;
+            query?: Record<string, string> | undefined;
+            headers?: Record<string, string> | undefined;
+        }, {
+            path?: Record<string, string> | undefined;
+            cookies?: Record<string, string> | undefined;
+            query?: Record<string, string> | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        parameters: {
+            path?: Record<string, string> | undefined;
+            cookies?: Record<string, string> | undefined;
+            query?: Record<string, string> | undefined;
+            headers?: Record<string, string> | undefined;
+        };
+        name?: string | undefined;
+        body?: {
+            content: string | Record<string, any>;
+            encoding: "application/json" | "text/plain" | "text/html" | "application/javascript" | "application/xml" | "application/yaml" | "application/edn" | "application/octet-stream" | "application/x-www-form-urlencoded" | "multipart/form-data" | "binary";
+            file?: {
+                url: string;
+                base64?: string | undefined;
+            } | null | undefined;
+        } | undefined;
+    }, {
+        parameters: {
+            path?: Record<string, string> | undefined;
+            cookies?: Record<string, string> | undefined;
+            query?: Record<string, string> | undefined;
+            headers?: Record<string, string> | undefined;
+        };
+        name?: string | undefined;
+        body?: {
+            content: string | Record<string, any>;
+            encoding: "application/json" | "text/plain" | "text/html" | "application/javascript" | "application/xml" | "application/yaml" | "application/edn" | "application/octet-stream" | "application/x-www-form-urlencoded" | "multipart/form-data" | "binary";
+            file?: {
+                url: string;
+                base64?: string | undefined;
+            } | null | undefined;
+        } | undefined;
+    }>>>;
+    'x-internal': import("zod").ZodOptional<import("zod").ZodBoolean>;
+    'x-scalar-ignore': import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, "x-scalar-examples">, {
+    type: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"request">>>;
+    uid: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    method: import("zod").ZodDefault<import("zod").ZodEnum<["connect", "delete", "get", "head", "options", "patch", "post", "put", "trace"]>>;
+    servers: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "many">>;
+    selectedServerUid: import("zod").ZodDefault<import("zod").ZodString>;
+    examples: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "many">>;
+    selectedSecuritySchemeUids: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "many">]>, "many">>;
+}>, "strip", import("zod").ZodTypeAny, {
+    path: string;
+    type: "request";
+    uid: string;
+    selectedSecuritySchemeUids: (string | string[])[];
+    selectedServerUid: string;
+    servers: string[];
+    examples: string[];
+    method: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace";
+    description?: string | undefined;
+    summary?: string | undefined;
+    externalDocs?: {
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    'x-internal'?: boolean | undefined;
+    'x-scalar-ignore'?: boolean | undefined;
+    security?: Record<string, string[]>[] | undefined;
+    tags?: string[] | undefined;
+    deprecated?: boolean | undefined;
+    operationId?: string | undefined;
+    parameters?: {
+        required: boolean;
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        deprecated: boolean;
+        description?: string | undefined;
+        example?: unknown;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        examples?: Record<string, {
+            value?: unknown;
+            summary?: string | undefined;
+        }> | undefined;
+    }[] | undefined;
+    requestBody?: any;
+    responses?: Record<string, any> | undefined;
+}, {
+    path?: string | undefined;
+    type?: "request" | undefined;
+    uid?: string | undefined;
+    description?: string | undefined;
+    summary?: string | undefined;
+    externalDocs?: {
+        description?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    'x-internal'?: boolean | undefined;
+    'x-scalar-ignore'?: boolean | undefined;
+    security?: Record<string, string[] | undefined>[] | undefined;
+    selectedSecuritySchemeUids?: (string | (string | undefined)[] | undefined)[] | undefined;
+    selectedServerUid?: string | undefined;
+    servers?: (string | undefined)[] | undefined;
+    tags?: string[] | undefined;
+    deprecated?: boolean | undefined;
+    examples?: (string | undefined)[] | undefined;
+    operationId?: string | undefined;
+    parameters?: {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        required?: boolean | undefined;
+        description?: string | undefined;
+        example?: unknown;
+        deprecated?: boolean | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        examples?: Record<string, {
+            value?: unknown;
+            summary?: string | undefined;
+        }> | undefined;
+    }[] | undefined;
+    requestBody?: any;
+    responses?: Record<string, any> | undefined;
+    method?: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace" | undefined;
+}>;
+//# sourceMappingURL=operation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/operation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,OAAO,IAAI,WAAW,EAE5B,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAC7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgB,CAAA"}

package/dist/entities/spec/operation.js

@@ -0,0 +1,9 @@
+import { requestSchema } from './requests.js';
+
+/**
+ * Aliases Request to Operation which is closer to the spec,
+ * also will not conflict with the builtin Request class
+ */
+const operationSchema = requestSchema;
+
+export { operationSchema };