@scalar/api-reference 1.35.2 → 1.35.4

package/dist/components/Content/Schema/Schema.preview.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Schema.preview.d.ts","sourceRoot":"","sources":["../../../../src/components/Content/Schema/Schema.preview.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWxB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAA;AAWD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO3B,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWtB,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBhC,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgChC,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C3C,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D9B,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCjC,CAAA;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCvC,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyE/B,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CnC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD1C,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDlC,CAAA"}

package/dist/components/Content/Schema/SchemaDiscriminator.vue.d.ts

@@ -1,12 +0,0 @@
-import type { DiscriminatorMapping } from '../../../hooks/useDiscriminator.js';
-type __VLS_Props = {
-    discriminatorMapping: DiscriminatorMapping;
-    discriminator: string;
-};
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "update:modelValue": (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;
-//# sourceMappingURL=SchemaDiscriminator.vue.d.ts.map

package/dist/components/Content/Schema/SchemaDiscriminator.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaDiscriminator.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Content/Schema/SchemaDiscriminator.vue"],"names":[],"mappings":"AAqEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAEpE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,aAAa,EAAE,MAAM,CAAA;CACtB,CAAC;;;;;;AAuHF,wBAOG"}

package/dist/components/Content/Schema/SchemaDiscriminator.vue.js

@@ -1,49 +0,0 @@
-import { defineComponent as p, ref as f, computed as n, createBlock as b, openBlock as g, unref as s, withCtx as v, createElementVNode as l, createVNode as x, toDisplayString as h } from "vue";
-import { ScalarListbox as V } from "@scalar/components";
-import { ScalarIconCaretDown as D } from "@scalar/icons";
-const S = {
-  class: "bg-b-1.5 hover:bg-b-2 mt-2 flex w-full items-center gap-1 rounded border px-2 py-1.25",
-  type: "button"
-}, _ = { class: "composition-selector-label text-c-1 relative" }, M = /* @__PURE__ */ p({
-  __name: "SchemaDiscriminator",
-  props: {
-    discriminatorMapping: {},
-    discriminator: {}
-  },
-  emits: ["update:modelValue"],
-  setup(i, { emit: c }) {
-    const m = f(""), d = c, u = (e) => {
-      m.value = e, d("update:modelValue", e);
-    }, a = n(() => i.discriminatorMapping ? Object.keys(i.discriminatorMapping).map((e) => ({
-      id: e,
-      label: e
-    })) : []), o = n({
-      get: () => a.value.find(
-        (e) => e.id === i.discriminator
-      ),
-      set: (e) => {
-        e != null && e.id && u(e.id);
-      }
-    });
-    return (e, r) => (g(), b(s(V), {
-      modelValue: o.value,
-      "onUpdate:modelValue": r[0] || (r[0] = (t) => o.value = t),
-      options: a.value,
-      resize: ""
-    }, {
-      default: v(() => {
-        var t;
-        return [
-          l("button", S, [
-            l("span", _, h(((t = o.value) == null ? void 0 : t.label) || "Schema"), 1),
-            x(s(D), { class: "z-1" })
-          ])
-        ];
-      }),
-      _: 1
-    }, 8, ["modelValue", "options"]));
-  }
-});
-export {
-  M as default
-};

package/dist/components/Content/Schema/SchemaDiscriminator.vue2.js

@@ -1,4 +0,0 @@
-import f from "./SchemaDiscriminator.vue.js";
-export {
-  f as default
-};

package/dist/components/Content/Schema/SchemaPropertyDescription.vue.d.ts

@@ -1,13 +0,0 @@
-declare var __VLS_1: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
-};
-declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-//# sourceMappingURL=SchemaPropertyDescription.vue.d.ts.map

package/dist/components/Content/Schema/SchemaPropertyDescription.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaPropertyDescription.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Content/Schema/SchemaPropertyDescription.vue"],"names":[],"mappings":"AAsBA,QAAA,IAAI,OAAO,IAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAkB/C,QAAA,MAAM,eAAe,+QAKnB,CAAC;wBACkB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;AAAzE,wBAA0E;AAE1E,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/features/Operation/components/ParameterHeaders.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParameterHeaders.vue.d.ts","sourceRoot":"","sources":["../../../../src/features/Operation/components/ParameterHeaders.vue"],"names":[],"mappings":"AA0HA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAIxD,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,YAAY,CAAA;KAAE,CAAA;IACpD,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB,CAAC;;AA4JF,wBAMG"}

package/dist/features/Operation/components/ParameterHeaders.vue.js

@@ -1,7 +0,0 @@
-import r from "./ParameterHeaders.vue2.js";
-import "./ParameterHeaders.vue3.js";
-import o from "../../../_virtual/_plugin-vue_export-helper.js";
-const m = /* @__PURE__ */ o(r, [["__scopeId", "data-v-96f30d93"]]);
-export {
-  m as default
-};

package/dist/features/Operation/components/ParameterHeaders.vue2.js

@@ -1,64 +0,0 @@
-import { defineComponent as f, createBlock as m, openBlock as r, unref as s, withCtx as c, createElementVNode as u, normalizeClass as d, createVNode as o, createElementBlock as l, Fragment as i, createTextVNode as p, renderList as b } from "vue";
-import { Disclosure as v, DisclosureButton as _, DisclosurePanel as k } from "@headlessui/vue";
-import { ScalarIcon as B } from "@scalar/components";
-import H from "../../../components/Content/Schema/SchemaProperty.vue.js";
-const V = /* @__PURE__ */ f({
-  __name: "ParameterHeaders",
-  props: {
-    headers: {},
-    breadcrumb: {}
-  },
-  setup(S) {
-    function h(e) {
-      return e.schema !== void 0;
-    }
-    return (e, y) => (r(), m(s(v), null, {
-      default: c(({ open: a }) => [
-        u("div", {
-          class: d(["headers-card headers-card--compact", [{ "headers-card--open": a }]])
-        }, [
-          u("div", {
-            class: d(["headers-properties", { "headers-properties-open": a }])
-          }, [
-            o(s(_), {
-              class: "headers-card-title headers-card-title--compact",
-              style: {
-                top: "calc(var(--refs-header-height)))"
-              }
-            }, {
-              default: c(() => [
-                o(s(B), {
-                  class: d(["headers-card-title-icon", { "headers-card-title-icon--open": a }]),
-                  icon: "Add",
-                  size: "sm"
-                }, null, 8, ["class"]),
-                a ? (r(), l(i, { key: 0 }, [
-                  p(" Hide Headers ")
-                ], 64)) : (r(), l(i, { key: 1 }, [
-                  p(" Show Headers ")
-                ], 64))
-              ]),
-              _: 2
-            }, 1024),
-            o(s(k), null, {
-              default: c(() => [
-                (r(!0), l(i, null, b(e.headers, (t, n) => (r(), m(H, {
-                  breadcrumb: e.breadcrumb ? [...e.breadcrumb, "headers"] : void 0,
-                  key: n,
-                  description: t.description,
-                  name: `${n}`,
-                  value: h(t) ? t.schema : void 0
-                }, null, 8, ["breadcrumb", "description", "name", "value"]))), 128))
-              ]),
-              _: 1
-            })
-          ], 2)
-        ], 2)
-      ]),
-      _: 1
-    }));
-  }
-});
-export {
-  V as default
-};

package/dist/features/Operation/components/ParameterList.vue3.js

@@ -1,4 +0,0 @@
-const e = "";
-export {
-  e as default
-};

package/dist/features/Operation/hooks/useResponses.d.ts

@@ -1,17 +0,0 @@
-import type { OpenAPI, OpenAPIV3_1 } from '@scalar/openapi-types';
-import type { RequestBodyMimeTypes } from '@scalar/types/legacy';
-/**
- * Generates the responses for the request from the parameters in the OpenAPI document
- */
-export declare function useResponses(responses: OpenAPIV3_1.ResponseObject | undefined): {
-    responses: import("vue").ComputedRef<{
-        name: string;
-        description: string;
-        content: RequestBodyMimeTypes;
-        headers?: {
-            [key: string]: OpenAPI.HeaderObject;
-        };
-        schema?: OpenAPI.SchemaObject;
-    }[]>;
-};
-//# sourceMappingURL=useResponses.d.ts.map

package/dist/features/Operation/hooks/useResponses.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useResponses.d.ts","sourceRoot":"","sources":["../../../../src/features/Operation/hooks/useResponses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAGhE;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,WAAW,CAAC,cAAc,GAAG,SAAS;;cAGlE,MAAM;qBACC,MAAM;iBACV,oBAAoB;kBACnB;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAA;SAAE;iBACxC,OAAO,CAAC,YAAY;;EAoBlC"}

package/dist/features/Operation/hooks/useResponses.js

@@ -1,19 +0,0 @@
-import { computed as o } from "vue";
-function u(n) {
-  return { responses: o(() => {
-    const e = [];
-    return n && Object.entries(n).forEach(([c, t]) => {
-      var r;
-      e.push({
-        name: c,
-        description: t.description,
-        content: t.content,
-        headers: t.headers,
-        schema: (r = t.content) == null ? void 0 : r.schema
-      });
-    }), e;
-  }) };
-}
-export {
-  u as useResponses
-};

package/dist/hooks/useDiscriminator.d.ts

@@ -1,53 +0,0 @@
-import type { Schemas } from '../features/Operation/types/schemas';
-import type { OpenAPIV3_1 } from '@scalar/openapi-types';
-import { type InjectionKey, type ComputedRef } from 'vue';
-/** Discriminator context type */
-export type DiscriminatorContext = {
-    selectedType: string | undefined;
-    discriminatorMapping: Record<string, string>;
-    discriminatorPropertyName: string;
-    hasDiscriminator: boolean;
-    mergedSchema: OpenAPIV3_1.SchemaObject | undefined;
-};
-/** Example context type */
-export type ExampleContext = {
-    generateExampleValue: (isArray?: boolean) => any;
-};
-/** Injection keys */
-export declare const DISCRIMINATOR_CONTEXT: InjectionKey<ComputedRef<DiscriminatorContext | null>>;
-export declare const EXAMPLE_CONTEXT: InjectionKey<ExampleContext>;
-/** Discriminator mapping */
-export type DiscriminatorMapping = NonNullable<OpenAPIV3_1.DiscriminatorObject['mapping']>;
-/** Discriminator property name */
-export type DiscriminatorPropertyName = OpenAPIV3_1.DiscriminatorObject['propertyName'];
-/** Use discriminator options */
-export type UseDiscriminatorOptions = {
-    schema: OpenAPIV3_1.SchemaObject | undefined;
-    schemas?: Schemas;
-    onSchemaChange?: (newSchema: OpenAPIV3_1.SchemaObject) => void;
-};
-/** Get discriminator mapping from schema */
-export declare function getDiscriminatorMapping(schema: OpenAPIV3_1.SchemaObject | undefined): DiscriminatorMapping | undefined;
-/** Get discriminator property name from schema */
-export declare function getDiscriminatorPropertyName(schema: OpenAPIV3_1.SchemaObject | undefined): DiscriminatorPropertyName | undefined;
-/** Check if schema has a discriminator */
-export declare function hasDiscriminator(schema: OpenAPIV3_1.SchemaObject | undefined): boolean;
-/** Get base discriminator schema name by matching discriminator property */
-export declare function getBaseDiscriminatorSchemaName(discriminatorPropertyName: string, schemas?: Schemas): string | null;
-/** Get base discriminator schema name for array items that might reference a discriminator schema */
-export declare function getDiscriminatorSchemaName(itemsSchema: OpenAPIV3_1.SchemaObject | undefined, schemas?: Schemas): string | null;
-/** Merge discriminator schemas */
-export declare function mergeDiscriminatorSchemas(baseSchema: OpenAPIV3_1.SchemaObject, selectedType: string, schemas: Record<string, OpenAPIV3_1.SchemaObject>): OpenAPIV3_1.SchemaObject | undefined;
-/** Use discriminator hook */
-export declare function useDiscriminator({ schema, schemas, onSchemaChange }: UseDiscriminatorOptions): {
-    selectedType: import("vue").Ref<string, string>;
-    discriminatorMapping: ComputedRef<{
-        [value: string]: string;
-    } | undefined>;
-    defaultType: ComputedRef<string>;
-    discriminatorPropertyName: ComputedRef<string | undefined>;
-    hasDiscriminator: ComputedRef<boolean>;
-    mergedSchema: ComputedRef<OpenAPIV3_1.SchemaObject | undefined>;
-    generateExampleValue: (isArray?: boolean) => any;
-};
-//# sourceMappingURL=useDiscriminator.d.ts.map

package/dist/hooks/useDiscriminator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDiscriminator.d.ts","sourceRoot":"","sources":["../../src/hooks/useDiscriminator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,EAAwB,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAA;AAE/E,iCAAiC;AACjC,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5C,yBAAyB,EAAE,MAAM,CAAA;IACjC,gBAAgB,EAAE,OAAO,CAAA;IACzB,YAAY,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,CAAA;CACnD,CAAA;AAED,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG;IAC3B,oBAAoB,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,GAAG,CAAA;CACjD,CAAA;AAED,qBAAqB;AACrB,eAAO,MAAM,qBAAqB,EAAsC,YAAY,CAClF,WAAW,CAAC,oBAAoB,GAAG,IAAI,CAAC,CACzC,CAAA;AACD,eAAO,MAAM,eAAe,EAAgC,YAAY,CAAC,cAAc,CAAC,CAAA;AAExF,4BAA4B;AAC5B,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,WAAW,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,CAAA;AAE1F,kCAAkC;AAClC,MAAM,MAAM,yBAAyB,GAAG,WAAW,CAAC,mBAAmB,CAAC,cAAc,CAAC,CAAA;AAEvF,gCAAgC;AAChC,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,CAAA;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,WAAW,CAAC,YAAY,KAAK,IAAI,CAAA;CAC/D,CAAA;AAED,4CAA4C;AAC5C,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,GAC3C,oBAAoB,GAAG,SAAS,CAKlC;AAED,kDAAkD;AAClD,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,GAC3C,yBAAyB,GAAG,SAAS,CAEvC;AAED,0CAA0C;AAC1C,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,GAAG,OAAO,CAEtF;AAED,4EAA4E;AAC5E,wBAAgB,8BAA8B,CAAC,yBAAyB,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAiBlH;AAED,qGAAqG;AACrG,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,GAAG,IAAI,CAsBf;AAgBD,kCAAkC;AAClC,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,WAAW,CAAC,YAAY,EACpC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,YAAY,CAAC,GAChD,WAAW,CAAC,YAAY,GAAG,SAAS,CA6EtC;AAED,6BAA6B;AAC7B,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,uBAAuB;;;;;;;;;;EAuI5F"}

package/dist/hooks/useDiscriminator.js

@@ -1,149 +0,0 @@
-import { computed as c, ref as q, watch as O } from "vue";
-const V = Symbol("discriminator-context"), w = Symbol("example-context");
-function j(r) {
-  var e;
-  if ((e = r == null ? void 0 : r.discriminator) != null && e.mapping)
-    return r.discriminator.mapping;
-}
-function E(r) {
-  var e;
-  return (e = r == null ? void 0 : r.discriminator) == null ? void 0 : e.propertyName;
-}
-function D(r) {
-  return (r == null ? void 0 : r.discriminator) !== void 0;
-}
-function I(r, e) {
-  var o;
-  if (!r || !e || r.type !== "object" || !r.properties)
-    return null;
-  for (const [p, i] of Object.entries(e))
-    if (typeof i == "object" && i !== null && "discriminator" in i && ((o = i.discriminator) != null && o.propertyName)) {
-      const n = i.discriminator.propertyName;
-      if (r.properties[n])
-        return p;
-    }
-  return null;
-}
-function x(r) {
-  if (r)
-    return r.type === "array" && r.items && typeof r.items == "object" && !("$ref" in r.items) ? r.items : r;
-}
-function T(r, e, o) {
-  var l;
-  if (!((l = r.discriminator) != null && l.mapping) || !e)
-    return;
-  const p = r.discriminator.mapping[e];
-  if (!p)
-    return;
-  const i = p.split("/").pop();
-  if (!i || !o[i])
-    return;
-  const n = o[i];
-  if (n.allOf) {
-    const d = {
-      type: n.type || "object",
-      properties: {},
-      required: [],
-      ...r.title ? { title: r.title } : {},
-      ...r.name ? { name: r.name } : {}
-    }, y = {}, a = /* @__PURE__ */ new Set();
-    r.required && r.required.forEach((u) => a.add(u));
-    for (const u of n.allOf)
-      if ("$ref" in u) {
-        const s = u.$ref.split("/").pop();
-        if (s && o[s]) {
-          const t = o[s];
-          t.properties && Object.assign(y, t.properties), t.required && t.required.forEach((f) => a.add(f));
-        }
-      } else "properties" in u && (Object.assign(y, u.properties), "required" in u && Array.isArray(u.required) && u.required.forEach((s) => a.add(s)));
-    return d.properties = y, d.required = Array.from(a), d;
-  }
-  return {
-    type: n.type || r.type,
-    properties: {
-      ...r.properties || {},
-      ...n.properties || {}
-    },
-    required: [...r.required || [], ...n.required || []],
-    // Preserve discriminator
-    discriminator: r.discriminator,
-    // Preserve title and name from base schema
-    ...r.title ? { title: r.title } : {},
-    ...r.name ? { name: r.name } : {}
-  };
-}
-function X({ schema: r, schemas: e, onSchemaChange: o }) {
-  const p = c(() => x(r)), i = c(() => j(p.value)), n = c(() => i.value && Object.keys(i.value)[0] || ""), l = q(n.value);
-  O(
-    n,
-    (t) => {
-      t && !l.value && (l.value = t);
-    },
-    { immediate: !0 }
-  );
-  const d = c(() => E(p.value)), y = c(() => D(p.value)), a = c(() => {
-    if (!p.value || !e || !l.value)
-      return r;
-    const t = T(
-      p.value,
-      l.value,
-      e
-    );
-    if (!t)
-      return r;
-    const f = (r == null ? void 0 : r.type) === "array" ? {
-      type: "array",
-      items: t,
-      ...r.title ? { title: r.title } : {},
-      ...r.name ? { name: r.name } : {}
-    } : t;
-    return o == null || o(f), f;
-  }), u = (t) => {
-    if ("default" in t)
-      return t.default;
-    if ("example" in t)
-      return t.example;
-    switch (t.type) {
-      case "string":
-        return "";
-      case "integer":
-      case "number":
-        return t.nullable ? null : 0;
-      case "boolean":
-        return !1;
-      case "array":
-        return [];
-      case "object":
-        return {};
-      default:
-        return null;
-    }
-  };
-  return {
-    selectedType: l,
-    discriminatorMapping: i,
-    defaultType: n,
-    discriminatorPropertyName: d,
-    hasDiscriminator: y,
-    mergedSchema: a,
-    generateExampleValue: (t = !1) => {
-      if (!a.value)
-        return t ? [] : {};
-      const f = {}, v = a.value.type === "array" ? a.value.items : a.value;
-      return "properties" in v && v.properties && Object.entries(v.properties).forEach(([g, N]) => {
-        const m = N;
-        m !== null && (f[g] = u(m));
-      }), d.value && l.value && (f[d.value] = l.value), JSON.parse(JSON.stringify(t ? [f] : f));
-    }
-  };
-}
-export {
-  V as DISCRIMINATOR_CONTEXT,
-  w as EXAMPLE_CONTEXT,
-  j as getDiscriminatorMapping,
-  E as getDiscriminatorPropertyName,
-  I as getDiscriminatorSchemaName,
-  D as hasDiscriminator,
-  T as mergeDiscriminatorSchemas,
-  X as useDiscriminator
-};

package/dist/hooks/useOperationDiscriminator.d.ts

@@ -1,8 +0,0 @@
-import type { OpenAPIV3_1 } from '@scalar/openapi-types';
-import type { Schemas } from '../features/Operation/types/schemas';
-/** Handling discriminator logic in operations */
-export declare function useOperationDiscriminator(operation?: OpenAPIV3_1.OperationObject, schemas?: Schemas): {
-    hasSchemaDiscriminator: import("vue").ComputedRef<boolean>;
-    handleDiscriminatorChange: (type: string) => void;
-};
-//# sourceMappingURL=useOperationDiscriminator.d.ts.map

package/dist/hooks/useOperationDiscriminator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useOperationDiscriminator.d.ts","sourceRoot":"","sources":["../../src/hooks/useOperationDiscriminator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAA;AAsBjE,iDAAiD;AACjD,wBAAgB,yBAAyB,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,eAAe,EAAE,OAAO,CAAC,EAAE,OAAO;;sCA6DzD,MAAM;EAahD"}

package/dist/hooks/useOperationDiscriminator.js

@@ -1,57 +0,0 @@
-import { computed as i, ref as T, provide as t } from "vue";
-import { useDiscriminator as C, DISCRIMINATOR_CONTEXT as d, EXAMPLE_CONTEXT as p } from "./useDiscriminator.js";
-function E(e) {
-  return e ? !!(e.discriminator || e.type === "array" && e.items && typeof e.items == "object" && "discriminator" in e.items) : !1;
-}
-function j(e, f) {
-  var c, m, o;
-  const n = (o = (m = (c = e == null ? void 0 : e.requestBody) == null ? void 0 : c.content) == null ? void 0 : m["application/json"]) == null ? void 0 : o.schema, a = i(() => E(n)), h = a.value ? C({
-    schema: n,
-    schemas: f,
-    onSchemaChange: (r) => {
-      var u, l;
-      (l = (u = e == null ? void 0 : e.requestBody) == null ? void 0 : u.content) != null && l["application/json"] && (e.requestBody.content["application/json"].schema = r);
-    }
-  }) : {
-    selectedType: T(""),
-    discriminatorMapping: i(() => ({})),
-    discriminatorPropertyName: i(() => ""),
-    hasDiscriminator: i(() => !1),
-    mergedSchema: i(() => n),
-    generateExampleValue: () => ({})
-  }, {
-    selectedType: s,
-    discriminatorMapping: y,
-    discriminatorPropertyName: g,
-    hasDiscriminator: v,
-    mergedSchema: D,
-    generateExampleValue: S
-  } = h;
-  if (a.value) {
-    const r = i(() => ({
-      selectedType: s.value || void 0,
-      discriminatorMapping: y.value || {},
-      discriminatorPropertyName: g.value || "",
-      hasDiscriminator: v.value,
-      mergedSchema: D.value
-    }));
-    t(d, r), t(p, {
-      generateExampleValue: S
-    });
-  } else
-    t(
-      d,
-      i(() => null)
-    ), t(p, {
-      generateExampleValue: () => ({})
-    });
-  return {
-    hasSchemaDiscriminator: a,
-    handleDiscriminatorChange: (r) => {
-      a.value && (s.value = r);
-    }
-  };
-}
-export {
-  j as useOperationDiscriminator
-};