@scalar/api-reference 1.25.7 → 1.25.10

package/dist/embeds/OpenApiDocument/OpenApiDocument.vue.d.ts

@@ -0,0 +1,508 @@
+import type { OpenApiDocumentConfiguration } from './types';
+declare const dereferenced: import("vue").Ref<{
+    [x: `x-${string}`]: any;
+    [x: string]: any;
+    openapi?: "3.0.0" | "3.0.1" | "3.0.2" | "3.0.2";
+    swagger?: undefined;
+    info?: {
+        title?: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        license?: {
+            name?: string;
+            url?: string;
+        } | undefined;
+        version?: string;
+    } | undefined;
+    servers?: {
+        url?: string;
+        description?: string;
+        variables?: {
+            [variable: string]: import("@scalar/openapi-types").OpenAPIV3.ServerVariableObject;
+        };
+    }[] | undefined;
+    paths?: import("@scalar/openapi-types").OpenAPIV3.PathsObject<{}, {}> | undefined;
+    components?: {
+        schemas?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.SchemaObject;
+        };
+        responses?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ResponseObject;
+        };
+        parameters?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ParameterObject;
+        };
+        examples?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ExampleObject;
+        };
+        requestBodies?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.RequestBodyObject;
+        };
+        headers?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.HeaderObject;
+        };
+        securitySchemes?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.SecuritySchemeObject;
+        };
+        links?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.LinkObject;
+        };
+        callbacks?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.CallbackObject;
+        };
+    } | undefined;
+    security?: import("@scalar/openapi-types").OpenAPIV3.SecurityRequirementObject[];
+    tags?: {
+        [x: `x-${string}`]: any;
+        [x: string]: any;
+        name?: string;
+        description?: string;
+        externalDocs?: {
+            description?: string;
+            url?: string;
+        } | undefined;
+    }[] | undefined;
+    externalDocs?: {
+        description?: string;
+        url?: string;
+    } | undefined;
+} | {
+    [x: `x-${string}`]: any;
+    [x: string]: any;
+    openapi?: "3.1.0";
+    swagger?: undefined;
+    info?: {
+        description?: string;
+        title?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        version?: string;
+        summary?: string;
+        license?: {
+            url?: string;
+            name?: string;
+            identifier?: string;
+        } | undefined;
+    } | undefined;
+    jsonSchemaDialect?: string;
+    servers?: {
+        url?: string;
+        description?: string;
+        variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject>;
+    }[] | undefined;
+    paths?: import("@scalar/openapi-types").OpenAPIV3_1.PathsObject<{}, {}> | undefined;
+    components?: {
+        schemas?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.SchemaObject>;
+        responses?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ResponseObject>;
+        parameters?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ParameterObject>;
+        examples?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ExampleObject>;
+        requestBodies?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.RequestBodyObject>;
+        headers?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.HeaderObject>;
+        securitySchemes?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.SecuritySchemeObject>;
+        links?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.LinkObject>;
+        callbacks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.CallbackObject>;
+        pathItems?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject>;
+    } | undefined;
+    webhooks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject | import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject>;
+} | {
+    [x: `x-${string}`]: any;
+    [x: string]: any;
+    openapi?: "3.1.0";
+    swagger?: undefined;
+    info?: {
+        description?: string;
+        title?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        version?: string;
+        summary?: string;
+        license?: {
+            url?: string;
+            name?: string;
+            identifier?: string;
+        } | undefined;
+    } | undefined;
+    jsonSchemaDialect?: string;
+    servers?: {
+        url?: string;
+        description?: string;
+        variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject>;
+    }[] | undefined;
+    webhooks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject | import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject>;
+    paths?: import("@scalar/openapi-types").OpenAPIV3_1.PathsObject<{}, {}> | undefined;
+    components?: {
+        schemas?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.SchemaObject>;
+        responses?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ResponseObject>;
+        parameters?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ParameterObject>;
+        examples?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ExampleObject>;
+        requestBodies?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.RequestBodyObject>;
+        headers?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.HeaderObject>;
+        securitySchemes?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.SecuritySchemeObject>;
+        links?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.LinkObject>;
+        callbacks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.CallbackObject>;
+        pathItems?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject>;
+    } | undefined;
+} | {
+    [x: `x-${string}`]: any;
+    [x: string]: any;
+    openapi?: "3.1.0";
+    swagger?: undefined;
+    info?: {
+        description?: string;
+        title?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        version?: string;
+        summary?: string;
+        license?: {
+            url?: string;
+            name?: string;
+            identifier?: string;
+        } | undefined;
+    } | undefined;
+    jsonSchemaDialect?: string;
+    servers?: {
+        url?: string;
+        description?: string;
+        variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject>;
+    }[] | undefined;
+    components?: {
+        schemas?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.SchemaObject>;
+        responses?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ResponseObject>;
+        parameters?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ParameterObject>;
+        examples?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ExampleObject>;
+        requestBodies?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.RequestBodyObject>;
+        headers?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.HeaderObject>;
+        securitySchemes?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.SecuritySchemeObject>;
+        links?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.LinkObject>;
+        callbacks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.CallbackObject>;
+        pathItems?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject>;
+    } | undefined;
+    paths?: import("@scalar/openapi-types").OpenAPIV3_1.PathsObject<{}, {}> | undefined;
+    webhooks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject | import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject>;
+} | {
+    [x: `x-${string}`]: any;
+    [x: string]: any;
+    swagger?: "2.0";
+    openapi?: never;
+    basePath?: string;
+    consumes?: string[] | undefined;
+    definitions?: import("@scalar/openapi-types").OpenAPIV2.DefinitionsObject;
+    externalDocs?: {
+        [x: string]: any;
+        description?: string;
+        url?: string;
+    } | undefined;
+    host?: string;
+    info?: {
+        title?: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        license?: {
+            name?: string;
+            url?: string;
+        } | undefined;
+        version?: string;
+    } | undefined;
+    parameters?: import("@scalar/openapi-types").OpenAPIV2.ParametersDefinitionsObject;
+    paths?: import("@scalar/openapi-types").OpenAPIV2.PathsObject<{}> | undefined;
+    produces?: string[] | undefined;
+    responses?: import("@scalar/openapi-types").OpenAPIV2.ResponsesDefinitionsObject;
+    schemes?: string[];
+    security?: import("@scalar/openapi-types").OpenAPIV2.SecurityRequirementObject[];
+    securityDefinitions?: import("@scalar/openapi-types").OpenAPIV2.SecurityDefinitionsObject;
+    tags?: {
+        [x: `x-${string}`]: any;
+        [x: string]: any;
+        name?: string;
+        description?: string;
+        externalDocs?: {
+            [x: string]: any;
+            description?: string;
+            url?: string;
+        } | undefined;
+    }[] | undefined;
+} | undefined>;
+declare const version: import("vue").Ref<string | undefined>;
+declare const errors: import("vue").Ref<{
+    message: string;
+    code?: keyof typeof import("@scalar/openapi-parser").ERRORS | string;
+}[]>;
+declare const parsedSpec: {
+    tags?: {
+        name: string;
+        description: string;
+        operations: {
+            httpVerb: "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | "TRACE" | "CONNECT" | "DELETE" | "OPTIONS";
+            path: string;
+            operationId?: string;
+            name?: string;
+            description?: string;
+            information?: {
+                description?: string;
+                operationId?: string | number;
+                parameters?: {
+                    name: string;
+                    in?: string;
+                    description?: string;
+                    required?: boolean;
+                    deprecated?: boolean;
+                    allowEmptyValue?: boolean;
+                    style?: "form" | "simple";
+                    explode?: boolean;
+                    allowReserved?: boolean;
+                    schema?: {
+                        type: string;
+                        name?: string;
+                        example?: any;
+                        default?: any;
+                        format?: string;
+                        description?: string;
+                        properties?: Record<string, import("@scalar/types/legacy").Schema>;
+                    } | undefined;
+                    example?: any;
+                    examples?: (Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>) | undefined;
+                    content?: import("@scalar/types/legacy").RequestBodyMimeTypes;
+                }[] | undefined;
+                responses?: Record<string, import("@scalar/types/legacy").ScalarResponse>;
+                security?: import("@scalar/openapi-types").OpenAPIV3.SecurityRequirementObject[];
+                requestBody?: {
+                    description?: string;
+                    required?: boolean;
+                    content?: import("@scalar/types/legacy").RequestBodyMimeTypes;
+                } | undefined;
+                summary?: string;
+                tags?: string[];
+                deprecated?: boolean;
+                'x-custom-examples'?: {
+                    lang: string;
+                    label: string;
+                    source: string;
+                }[] | undefined;
+                'x-codeSamples'?: {
+                    lang: string;
+                    label: string;
+                    source: string;
+                }[] | undefined;
+                'x-code-samples'?: {
+                    lang: string;
+                    label: string;
+                    source: string;
+                }[] | undefined;
+            } | undefined;
+            pathParameters?: {
+                name: string;
+                in?: string;
+                description?: string;
+                required?: boolean;
+                deprecated?: boolean;
+                allowEmptyValue?: boolean;
+                style?: "form" | "simple";
+                explode?: boolean;
+                allowReserved?: boolean;
+                schema?: {
+                    type: string;
+                    name?: string;
+                    example?: any;
+                    default?: any;
+                    format?: string;
+                    description?: string;
+                    properties?: Record<string, import("@scalar/types/legacy").Schema>;
+                } | undefined;
+                example?: any;
+                examples?: (Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>) | undefined;
+                content?: import("@scalar/types/legacy").RequestBodyMimeTypes;
+            }[] | undefined;
+        }[];
+        'x-displayName'?: string;
+    }[] | undefined;
+    info: {
+        title?: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        license?: {
+            name?: string;
+            url?: string;
+        } | undefined;
+        version?: string;
+    } | {
+        title?: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        license?: {
+            name?: string;
+            url?: string;
+        } | undefined;
+        version?: string;
+    } | {
+        description?: string;
+        title?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        } | undefined;
+        version?: string;
+        summary?: string;
+        license?: {
+            url?: string;
+            name?: string;
+            identifier?: string;
+        } | undefined;
+    } | undefined;
+    host?: import("@scalar/openapi-types").OpenAPIV2.Document["host"];
+    basePath?: import("@scalar/openapi-types").OpenAPIV2.Document["basePath"];
+    schemes?: import("@scalar/openapi-types").OpenAPIV2.Document["schemes"];
+    externalDocs?: {
+        url: string;
+        description?: string;
+    } | undefined;
+    servers?: {
+        url?: string;
+        description?: string;
+        variables?: {
+            [variable: string]: import("@scalar/openapi-types").OpenAPIV3.ServerVariableObject;
+        };
+    }[] | {
+        url?: string;
+        description?: string;
+        variables?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject>;
+    }[] | undefined;
+    components?: {
+        schemas?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.SchemaObject;
+        };
+        responses?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ResponseObject;
+        };
+        parameters?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ParameterObject;
+        };
+        examples?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.ExampleObject;
+        };
+        requestBodies?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.RequestBodyObject;
+        };
+        headers?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.HeaderObject;
+        };
+        securitySchemes?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.SecuritySchemeObject;
+        };
+        links?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.LinkObject;
+        };
+        callbacks?: {
+            [key: string]: import("@scalar/openapi-types").OpenAPIV3.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3.CallbackObject;
+        };
+    } | {
+        schemas?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.SchemaObject>;
+        responses?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ResponseObject>;
+        parameters?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ParameterObject>;
+        examples?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.ExampleObject>;
+        requestBodies?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.RequestBodyObject>;
+        headers?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.HeaderObject>;
+        securitySchemes?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.SecuritySchemeObject>;
+        links?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.LinkObject>;
+        callbacks?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.CallbackObject>;
+        pathItems?: Record<string, import("@scalar/openapi-types").OpenAPIV3_1.ReferenceObject | import("@scalar/openapi-types").OpenAPIV3_1.PathItemObject>;
+    } | undefined;
+    webhooks?: import("@scalar/types/legacy").Webhooks;
+    definitions?: import("@scalar/types/legacy").Definitions;
+    swagger?: import("@scalar/openapi-types").OpenAPIV2.Document["swagger"];
+    openapi?: import("@scalar/openapi-types").OpenAPIV3.Document["openapi"] | import("@scalar/openapi-types").OpenAPIV3_1.Document["openapi"];
+    'x-tagGroups'?: {
+        name: string;
+        tags: string[];
+    }[] | undefined;
+    security?: import("@scalar/openapi-types").OpenAPIV3.SecurityRequirementObject[];
+};
+declare function __VLS_template(): Readonly<{
+    default(props: {
+        /** The given configuration */
+        configuration?: OpenApiDocumentConfiguration;
+        /** Errors, that came up when dereferencing */
+        errors: typeof errors.value;
+        /** OpenAPI version of the given document */
+        version: typeof version.value;
+        /** The dereferenced OpenAPI Document */
+        dereferenced: typeof dereferenced.value;
+        /**
+         * Dereferenced, normalized and parsedSpec OpenAPI document
+         * @deprecated We’ll remove this in the future.
+         */
+        parsedSpec: typeof parsedSpec;
+    }): any;
+}> & {
+    default(props: {
+        /** The given configuration */
+        configuration?: OpenApiDocumentConfiguration;
+        /** Errors, that came up when dereferencing */
+        errors: typeof errors.value;
+        /** OpenAPI version of the given document */
+        version: typeof version.value;
+        /** The dereferenced OpenAPI Document */
+        dereferenced: typeof dereferenced.value;
+        /**
+         * Dereferenced, normalized and parsedSpec OpenAPI document
+         * @deprecated We’ll remove this in the future.
+         */
+        parsedSpec: typeof parsedSpec;
+    }): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+    configuration?: OpenApiDocumentConfiguration;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    configuration?: OpenApiDocumentConfiguration;
+}>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+//# sourceMappingURL=OpenApiDocument.vue.d.ts.map

package/dist/embeds/OpenApiDocument/OpenApiDocument.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApiDocument.vue.d.ts","sourceRoot":"","sources":["../../../src/embeds/OpenApiDocument/OpenApiDocument.vue"],"names":[],"mappings":"AAqIA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAA;AAS3D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAwC,CAAA;AAC1D,QAAA,MAAM,OAAO,uCAA8B,CAAA;AAC3C,QAAA,MAAM,MAAM;;;IAAyB,CAAA;AAIrC,QAAA,MAAoB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG5B,CAAA;AA6EF,iBAAS,cAAc;mBAjDN;QACb,8BAA8B;QAC9B,aAAa,CAAC,EAAE,4BAA4B,CAAA;QAC5C,8CAA8C;QAC9C,MAAM,EAAE,OAAO,MAAM,CAAC,KAAK,CAAA;QAC3B,4CAA4C;QAC5C,OAAO,EAAE,OAAO,OAAO,CAAC,KAAK,CAAA;QAC7B,wCAAwC;QACxC,YAAY,EAAE,OAAO,YAAY,CAAC,KAAK,CAAA;QACvC;;;WAGG;QACH,UAAU,EAAE,OAAO,UAAU,CAAA;KAC9B,GAAG,GAAG;;mBAdQ;QACb,8BAA8B;QAC9B,aAAa,CAAC,EAAE,4BAA4B,CAAA;QAC5C,8CAA8C;QAC9C,MAAM,EAAE,OAAO,MAAM,CAAC,KAAK,CAAA;QAC3B,4CAA4C;QAC5C,OAAO,EAAE,OAAO,OAAO,CAAC,KAAK,CAAA;QAC7B,wCAAwC;QACxC,YAAY,EAAE,OAAO,YAAY,CAAC,KAAK,CAAA;QACvC;;;WAGG;QACH,UAAU,EAAE,OAAO,UAAU,CAAA;KAC9B,GAAG,GAAG;EAuFR;AACD,QAAA,MAAM,eAAe;oBA/IH,4BAA4B;;oBAA5B,4BAA4B;aAqJ5C,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AAOxG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACpC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC;AAEN,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AAC5D,KAAK,uBAAuB,CAAC,CAAC,IAAI;KAChC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACpC;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAC9D;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CACzD,CAAC"}

package/dist/embeds/OpenApiDocument/index.d.ts

@@ -0,0 +1,3 @@
+export { default as OpenApiDocument } from './OpenApiDocument.vue';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/embeds/OpenApiDocument/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/embeds/OpenApiDocument/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAClE,cAAc,SAAS,CAAA"}

package/dist/embeds/OpenApiDocument/types.d.ts

@@ -0,0 +1,3 @@
+import type { ReferenceConfiguration } from '../../types';
+export type OpenApiDocumentConfiguration = Partial<Pick<ReferenceConfiguration, 'proxy' | 'baseServerURL' | 'servers' | 'spec' | 'authentication' | 'defaultHttpClient' | 'hiddenClients'>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/embeds/OpenApiDocument/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/embeds/OpenApiDocument/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErD,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,IAAI,CACF,sBAAsB,EACpB,OAAO,GACP,eAAe,GACf,SAAS,GACT,MAAM,GACN,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,CAClB,CACF,CAAA"}

package/dist/embeds/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ExampleRequest';
+export * from './OpenApiDocument';
+//# sourceMappingURL=index.d.ts.map

package/dist/embeds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/embeds/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA"}

package/dist/features/BaseUrl/BaseUrl.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseUrl.vue.d.ts","sourceRoot":"","sources":["../../../src/features/BaseUrl/BaseUrl.vue"],"names":[],"mappings":"AAkIA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;;IAUtD;;OAEG;oBACa,IAAI;IACpB;;OAEG;uBACgB,MAAM;IACzB;;OAEG;cACO,MAAM,EAAE;;IAXlB;;OAEG;oBACa,IAAI;IACpB;;OAEG;uBACgB,MAAM;IACzB;;OAEG;cACO,MAAM,EAAE;;AA0KpB,wBAMG;AAOH,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AAC5D,KAAK,uBAAuB,CAAC,CAAC,IAAI;KAChC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACpC;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAC9D;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CACzD,CAAC"}
+{"version":3,"file":"BaseUrl.vue.d.ts","sourceRoot":"","sources":["../../../src/features/BaseUrl/BaseUrl.vue"],"names":[],"mappings":"AAsEA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;;IAQtD;;OAEG;oBACa,IAAI;IACpB;;OAEG;uBACgB,MAAM;IACzB;;OAEG;cACO,MAAM,EAAE;;IAXlB;;OAEG;oBACa,IAAI;IACpB;;OAEG;uBACgB,MAAM;IACzB;;OAEG;cACO,MAAM,EAAE;;AAgHpB,wBAMG;AAOH,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AAC5D,KAAK,uBAAuB,CAAC,CAAC,IAAI;KAChC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACpC;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAC9D;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CACzD,CAAC"}

package/dist/features/BaseUrl/BaseUrl.vue.js

@@ -1,97 +1,47 @@
-import { defineComponent as b, ref as S, watch as c, openBlock as U, createBlock as g, unref as u } from "vue";
-import j from "./ServerForm.vue.js";
-import { getServers as E } from "./utils/getServers.js";
-import { createEmptySpecification as O } from "../../helpers/createEmptySpecification.js";
-import { useServerStore as _ } from "../../legacy/stores/useServerStore.js";
-const w = /* @__PURE__ */ b({
+import { defineComponent as d, toRef as a, ref as m, watch as S, openBlock as b, createBlock as U, unref as n } from "vue";
+import _ from "./ServerForm.vue.js";
+import { useServerStore as B } from "../../legacy/stores/useServerStore.js";
+const C = /* @__PURE__ */ d({
   __name: "BaseUrl",
   props: {
     specification: {},
     defaultServerUrl: {},
     servers: {}
   },
-  setup(f) {
-    const a = f, { server: i, setServer: o } = _(), s = S(0);
-    c(
-      s,
+  setup(i) {
+    const s = i, v = a(s.specification), c = a(s.defaultServerUrl), p = a(s.servers), { server: t, setServer: o } = B({
+      specification: v,
+      defaultServerUrl: c,
+      servers: p
+    }), e = m(0);
+    S(
+      e,
       () => o({
-        selectedServer: s.value
+        selectedServer: e.value
       }),
       {
         immediate: !0
       }
-    ), c(
-      () => a.specification,
-      () => {
-        var r;
-        const t = (
-          // Use the specification
-          a.servers === void 0 ? a.specification : (
-            // Or create an empty one with the specified servers list
-            O({
-              servers: a.servers
-            })
-          )
-        ), e = E(t, {
-          defaultServerUrl: a.defaultServerUrl
-        });
-        o({
-          servers: e,
-          variables: {
-            // Set the initial values for the variables
-            ...m(
-              ((r = e[s.value]) == null ? void 0 : r.variables) ?? {}
-            ),
-            // Don’t overwrite existing values, but filter out non-existing variables
-            ...p(
-              i.variables,
-              e[s.value]
-            )
-          }
-        });
-      },
-      { deep: !0, immediate: !0 }
     );
-    function m(t) {
-      return Object.fromEntries(
-        Object.entries(t ?? {}).map(([e, r]) => {
-          var n, l, v;
-          return [
-            e,
-            // 1) Default
-            ((n = r.default) == null ? void 0 : n.toString()) ?? // 2) First enum value
-            ((v = (l = r.enum) == null ? void 0 : l[0]) == null ? void 0 : v.toString()) ?? // 3) Empty string
-            ""
-          ];
-        })
-      );
-    }
-    function p(t, e) {
-      return Object.fromEntries(
-        Object.entries(t).filter(
-          ([r]) => r in (e.variables ?? {})
-        )
-      );
-    }
-    function d(t, e) {
+    function f(l, r) {
       o({
         variables: {
-          ...i.variables,
-          [t]: e
+          ...t.variables,
+          [l]: r
         }
       });
     }
-    return (t, e) => (U(), g(j, {
-      selected: s.value,
-      servers: u(i).servers,
-      variables: u(i).variables,
-      "onUpdate:selected": e[0] || (e[0] = (r) => {
-        s.value = r;
+    return (l, r) => (b(), U(_, {
+      selected: e.value,
+      servers: n(t).servers,
+      variables: n(t).variables,
+      "onUpdate:selected": r[0] || (r[0] = (u) => {
+        e.value = u;
       }),
-      "onUpdate:variable": d
+      "onUpdate:variable": f
     }, null, 8, ["selected", "servers", "variables"]));
   }
 });
 export {
-  w as default
+  C as default
 };