@scalar/api-client 2.18.0 → 2.18.3

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthDataTable.vue.js

@@ -1,4 +1,4 @@
-import { defineComponent as f, computed as d, createElementBlock as s, openBlock as a, withModifiers as y, createCommentVNode as m, createBlock as x, normalizeClass as n, Fragment as g, renderList as k, createElementVNode as u, toDisplayString as w, unref as B, withCtx as U, createVNode as C } from "vue";
+import { defineComponent as f, computed as d, createElementBlock as c, openBlock as a, withModifiers as y, createCommentVNode as m, createBlock as g, normalizeClass as s, Fragment as p, renderList as k, createElementVNode as u, toDisplayString as w, unref as B, withCtx as U, createVNode as C } from "vue";
 import A from "./RequestAuthTab.vue.js";
 import z from "../../../components/data-table/DataTable.vue.js";
 const N = ["onClick"], O = { class: "relative z-10 font-medium whitespace-nowrap" }, T = {
@@ -17,47 +17,47 @@ const N = ["onClick"], O = { class: "relative z-10 font-medium whitespace-nowrap
     eventBus: {},
     meta: {}
   },
-  setup(t, { expose: h }) {
+  setup(e, { expose: h }) {
     const r = d(
-      () => t.selectedSchemeOptions[t.activeAuthIndex]
-    ), v = d(() => t.selectedSchemeOptions.length > 1), b = (e) => t.eventBus.emit("auth:update:active-index", {
-      index: e,
-      meta: t.meta
-    }), p = (e) => t.eventBus.emit("auth:update:security-scheme", {
-      payload: e,
-      name: r.value?.id ?? ""
-    }), S = (e) => t.eventBus.emit("auth:update:selected-scopes", {
-      ...e,
-      meta: t.meta
-    }), c = (e) => t.activeAuthIndex === e;
+      () => e.selectedSchemeOptions[e.activeAuthIndex]
+    ), b = d(() => e.selectedSchemeOptions.length > 1), v = (t) => e.eventBus.emit("auth:update:active-index", {
+      index: t,
+      meta: e.meta
+    }), x = (t, n) => e.eventBus.emit("auth:update:security-scheme", {
+      payload: t,
+      name: n
+    }), S = (t) => e.eventBus.emit("auth:update:selected-scopes", {
+      ...t,
+      meta: e.meta
+    }), o = (t) => e.activeAuthIndex === t;
     return h({
       activeScheme: r
-    }), (e, o) => (a(), s("form", {
-      onSubmit: o[0] || (o[0] = y(() => {
+    }), (t, n) => (a(), c("form", {
+      onSubmit: n[0] || (n[0] = y(() => {
       }, ["prevent"]))
     }, [
-      v.value ? (a(), s("div", {
+      b.value ? (a(), c("div", {
         key: 0,
-        class: n(["box-content flex flex-wrap gap-x-2.5 overflow-hidden border border-b-0 px-3", { "border-x-0": !e.isStatic }]),
+        class: s(["box-content flex flex-wrap gap-x-2.5 overflow-hidden border border-b-0 px-3", { "border-x-0": !e.isStatic }]),
         "data-testid": "auth-tabs"
       }, [
-        (a(!0), s(g, null, k(e.selectedSchemeOptions, (l, i) => (a(), s("div", {
+        (a(!0), c(p, null, k(e.selectedSchemeOptions, (l, i) => (a(), c("div", {
           key: l.id,
           class: "relative z-1 -mb-[var(--scalar-border-width)] flex h-8"
         }, [
           u("button", {
-            class: n(["floating-bg relative cursor-pointer border-b border-transparent py-1 text-sm font-medium transition-colors", c(i) ? "text-c-1" : "text-c-3"]),
+            class: s(["floating-bg relative cursor-pointer border-b border-transparent py-1 text-sm font-medium transition-colors", o(i) ? "text-c-1" : "text-c-3"]),
             type: "button",
-            onClick: (I) => b(i)
+            onClick: (I) => v(i)
           }, [
             u("span", O, w(l.label), 1)
           ], 10, N),
-          c(i) ? (a(), s("div", T)) : m("", !0)
+          o(i) ? (a(), c("div", T)) : m("", !0)
         ]))), 128))
       ], 2)) : m("", !0),
-      r.value ? (a(), x(B(z), {
+      r.value ? (a(), g(B(z), {
         key: 1,
-        class: n(["flex-1", { "bg-b-1 rounded-b-lg border border-t-0": e.isStatic }]),
+        class: s(["flex-1", { "bg-b-1 rounded-b-lg border border-t-0": e.isStatic }]),
         columns: [""],
         presentational: ""
       }, {
@@ -69,14 +69,14 @@ const N = ["onClick"], O = { class: "relative z-10 font-medium whitespace-nowrap
             securitySchemes: e.securitySchemes,
             selectedSecuritySchemas: r.value.value,
             server: e.server,
-            "onUpdate:securityScheme": p,
+            "onUpdate:securityScheme": x,
             "onUpdate:selectedScopes": S
           }, null, 8, ["environment", "isStatic", "proxyUrl", "securitySchemes", "selectedSecuritySchemas", "server"])
         ]),
         _: 1
-      }, 8, ["class"])) : (a(), s("div", {
+      }, 8, ["class"])) : (a(), c("div", {
         key: 2,
-        class: n(["bg-b-1 text-c-3 flex min-h-16 items-center justify-center border-t px-4 text-sm", { "min-h-[calc(4rem+0.5px)] rounded-b-lg border": e.isStatic }])
+        class: s(["bg-b-1 text-c-3 flex min-h-16 items-center justify-center border-t px-4 text-sm", { "min-h-[calc(4rem+0.5px)] rounded-b-lg border": e.isStatic }])
       }, " No authentication selected ", 2))
     ], 32));
   }

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthDataTableInput.vue.js

@@ -1,8 +1,8 @@
-import { defineComponent as p, mergeModels as u, useModel as f, useId as V, createBlock as y, openBlock as v, unref as o, mergeProps as C, withCtx as d, renderSlot as s, createElementVNode as B } from "vue";
-import b from "../../../components/data-table/DataTableInput.vue.js";
-const q = ["for"], $ = /* @__PURE__ */ p({
+import { defineComponent as f, mergeModels as d, useModel as p, useId as V, createBlock as y, openBlock as c, unref as a, mergeProps as v, withCtx as i, renderSlot as s, createElementVNode as C } from "vue";
+import B from "../../../components/data-table/DataTableInput.vue.js";
+const b = ["for"], O = /* @__PURE__ */ f({
   __name: "RequestAuthDataTableInput",
-  props: /* @__PURE__ */ u({
+  props: /* @__PURE__ */ d({
     containerClass: {},
     environment: {},
     readOnly: { type: Boolean, default: !1 },
@@ -12,35 +12,35 @@ const q = ["for"], $ = /* @__PURE__ */ p({
     modelValue: { default: "", required: !0 },
     modelModifiers: {}
   }),
-  emits: /* @__PURE__ */ u(["inputFocus", "inputBlur", "selectVariable"], ["update:modelValue"]),
-  setup(i, { emit: m }) {
-    const t = m, r = f(i, "modelValue"), a = V();
-    return (e, n) => (v(), y(o(b), C({ id: o(a) }, e.$attrs, {
-      modelValue: r.value,
-      "onUpdate:modelValue": n[0] || (n[0] = (l) => r.value = l),
-      canAddCustomEnumValue: !e.readOnly,
-      containerClass: e.containerClass,
-      environment: e.environment,
+  emits: /* @__PURE__ */ d(["inputFocus", "inputBlur", "selectVariable"], ["update:modelValue"]),
+  setup(t, { emit: m }) {
+    const l = m, u = p(t, "modelValue"), r = V();
+    return (o, e) => (c(), y(a(B), v({ id: a(r) }, o.$attrs, {
+      modelValue: u.value,
+      "onUpdate:modelValue": e[0] || (e[0] = (n) => u.value = n),
+      canAddCustomEnumValue: !t.readOnly,
+      containerClass: t.containerClass,
+      environment: t.environment,
       lineWrapping: "",
-      readOnly: e.readOnly,
-      required: e.required,
-      type: e.type,
-      onInputBlur: n[1] || (n[1] = (l) => t("inputBlur")),
-      onInputFocus: n[2] || (n[2] = (l) => t("inputFocus")),
-      onSelectVariable: n[3] || (n[3] = (l) => t("selectVariable", l))
+      readOnly: t.readOnly,
+      required: t.required,
+      type: t.type,
+      onInputBlur: e[1] || (e[1] = (n) => l("inputBlur")),
+      onInputFocus: e[2] || (e[2] = (n) => l("inputFocus")),
+      onSelectVariable: e[3] || (e[3] = (n) => l("selectVariable", n))
     }), {
-      default: d(() => [
-        B("label", { for: o(a) }, [
-          s(e.$slots, "default")
-        ], 8, q)
+      default: i(() => [
+        C("label", { for: a(r) }, [
+          s(o.$slots, "default")
+        ], 8, b)
       ]),
-      icon: d(() => [
-        s(e.$slots, "icon")
+      icon: i(() => [
+        s(o.$slots, "icon")
       ]),
       _: 3
     }, 16, ["id", "modelValue", "canAddCustomEnumValue", "containerClass", "environment", "readOnly", "required", "type"]));
   }
 });
 export {
-  $ as default
+  O as default
 };

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue.d.ts

@@ -108,7 +108,7 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                 'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
         } | undefined;
-    })) => any;
+    }), name: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:selectedScopes"?: ((payload: Omit<{
         id: string[];
@@ -208,7 +208,7 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                 'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
         } | undefined;
-    })) => any) | undefined;
+    }), name: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;
 //# sourceMappingURL=RequestAuthTab.vue.d.ts.map

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequestAuthTab.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue"],"names":[],"mappings":"AAmTA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,yBAAyB,EAEzB,YAAY,EACb,MAAM,8DAA8D,CAAA;AAcrE,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,kBAAkB,CAAA;IAC/B,yFAAyF;IACzF,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,uBAAuB,EAAE,yBAAyB,CAAA;IAClD,eAAe,EAAE,WAAW,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,CAAA;IACjE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;CAC5B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmiBF,wBAOG"}
+{"version":3,"file":"RequestAuthTab.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue"],"names":[],"mappings":"AA8TA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,yBAAyB,EAEzB,YAAY,EACb,MAAM,8DAA8D,CAAA;AAcrE,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,kBAAkB,CAAA;IAC/B,yFAAyF;IACzF,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,uBAAuB,EAAE,yBAAyB,CAAA;IAClD,eAAe,EAAE,WAAW,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,CAAA;IACjE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;CAC5B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8iBF,wBAOG"}

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue.js

@@ -1,11 +1,11 @@
-import { defineComponent as A, computed as N, ref as P, createElementBlock as s, openBlock as o, Fragment as d, renderList as U, createBlock as v, createCommentVNode as m, unref as i, withCtx as l, createVNode as n, createElementVNode as k, toDisplayString as R, createTextVNode as y, normalizeClass as z, capitalize as Q } from "vue";
-import { ScalarMarkdownSummary as q } from "@scalar/components";
-import { getResolvedRef as D } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import E from "./OAuth2.vue.js";
+import { defineComponent as A, computed as N, ref as P, createElementBlock as u, openBlock as l, Fragment as c, renderList as g, createBlock as y, createCommentVNode as f, unref as d, withCtx as r, createVNode as i, createElementVNode as V, toDisplayString as R, createTextVNode as v, normalizeClass as z, capitalize as Q } from "vue";
+import { ScalarMarkdownSummary as _ } from "@scalar/components";
+import { getResolvedRef as q } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import D from "./OAuth2.vue.js";
 import b from "./RequestAuthDataTableInput.vue.js";
-import c from "../../../components/data-table/DataTableRow.vue.js";
+import m from "../../../components/data-table/DataTableRow.vue.js";
 import I from "../../../components/data-table/DataTableCell.vue.js";
-const H = { class: "bg-b-1 text-c-2 outline-b-3 top-0 z-1 h-full w-full overflow-hidden px-3 py-1.25 text-ellipsis group-hover/auth:absolute group-hover/auth:h-auto group-hover/auth:border-b *:first:line-clamp-1 *:first:text-ellipsis group-hover/auth:*:first:line-clamp-none" }, L = { class: "flex min-h-8 border-t text-base" }, G = { class: "flex h-8 max-w-full gap-2.5 overflow-x-auto px-3" }, J = ["onClick"], W = { class: "relative z-10" }, oe = /* @__PURE__ */ A({
+const E = { class: "bg-b-1 text-c-2 outline-b-3 top-0 z-1 h-full w-full overflow-hidden px-3 py-1.25 text-ellipsis group-hover/auth:absolute group-hover/auth:h-auto group-hover/auth:border-b *:first:line-clamp-1 *:first:text-ellipsis group-hover/auth:*:first:line-clamp-none" }, H = { class: "flex min-h-8 border-t text-base" }, L = { class: "flex h-8 max-w-full gap-2.5 overflow-x-auto px-3" }, G = ["onClick"], J = { class: "relative z-10" }, le = /* @__PURE__ */ A({
   __name: "RequestAuthTab",
   props: {
     environment: {},
@@ -16,203 +16,211 @@ const H = { class: "bg-b-1 text-c-2 outline-b-3 top-0 z-1 h-full w-full overflow
     server: {}
   },
   emits: ["update:securityScheme", "update:selectedScopes"],
-  setup(f, { emit: K }) {
-    const x = K, C = N(
-      () => Object.entries(f.selectedSecuritySchemas).map(([r, e = []]) => ({
-        scheme: D(f.securitySchemes[r]),
-        name: r,
-        scopes: e
+  setup(n, { emit: K }) {
+    const x = K, $ = N(
+      () => Object.entries(n.selectedSecuritySchemas).map(([o, t = []]) => ({
+        scheme: q(n.securitySchemes[o]),
+        name: o,
+        scopes: t
       }))
-    ), w = P(""), h = N(() => C.value.length > 1), F = (r, e) => {
-      const t = Q(r), u = e.description ? `: ${e.description}` : "";
-      switch (e.type) {
+    ), w = P(""), C = N(() => $.value.length > 1), F = (o, t) => {
+      const e = Q(o), a = t.description ? `: ${t.description}` : "";
+      switch (t.type) {
         case "apiKey":
-          return `${t}${u || `: ${e.in}`}`;
+          return `${e}${a || `: ${t.in}`}`;
         case "oauth2": {
-          const V = Object.keys(e.flows ?? {})[0], a = w.value || V;
-          return `${t}: ${a}${u}`;
+          const k = Object.keys(t.flows ?? {})[0], s = w.value || k;
+          return `${e}: ${s}${a}`;
         }
         case "http":
-          return `${t}: ${e.scheme}${u}`;
+          return `${e}: ${t.scheme}${a}`;
         default:
-          return `${t}${u || `: ${e.type}`}`;
+          return `${e}${a || `: ${t.type}`}`;
       }
-    }, T = (r, e) => w.value === r || e === 0 && !w.value, B = () => f.isStatic && "border-t", g = (r, e) => x("update:securityScheme", {
-      type: "http",
-      [r]: e
-    }), j = (r, e) => x("update:securityScheme", {
-      type: "apiKey",
-      [r]: e
-    }), M = (r, e) => {
+    }, T = (o, t) => w.value === o || t === 0 && !w.value, B = () => n.isStatic && "border-t", h = (o, t, e) => x(
+      "update:securityScheme",
+      {
+        type: "http",
+        [o]: t
+      },
+      e
+    ), j = (o, t, e) => x(
+      "update:securityScheme",
+      {
+        type: "apiKey",
+        [o]: t
+      },
+      e
+    ), M = (o, t) => {
       x("update:selectedScopes", {
-        id: Object.keys(f.selectedSecuritySchemas),
-        name: r,
-        ...e
+        id: Object.keys(n.selectedSecuritySchemas),
+        name: o,
+        ...t
       });
-    }, O = (r, e) => {
-      const t = "floating-bg text-c-3 relative cursor-pointer border-b border-transparent py-1 text-base font-medium";
-      return T(r, e) ? `${t} !text-c-1 !rounded-none border-b !border-current ${f.isStatic ? "opacity-100" : ""}` : t;
+    }, O = (o, t) => {
+      const e = "floating-bg text-c-3 relative cursor-pointer border-b border-transparent py-1 text-base font-medium";
+      return T(o, t) ? `${e} !text-c-1 !rounded-none border-b !border-current ${n.isStatic ? "opacity-100" : ""}` : e;
     };
-    return (r, e) => (o(!0), s(d, null, U(C.value, ({ scheme: t, name: u, scopes: V }) => (o(), s(d, { key: u }, [
-      h.value && t ? (o(), v(i(c), { key: 0 }, {
-        default: l(() => [
-          n(i(I), {
-            "aria-label": F(u, t),
+    return (o, t) => (l(!0), u(c, null, g($.value, ({ scheme: e, name: a, scopes: k }) => (l(), u(c, { key: a }, [
+      C.value && e ? (l(), y(d(m), { key: 0 }, {
+        default: r(() => [
+          i(d(I), {
+            "aria-label": F(a, e),
             class: "text-c-2 group/auth flex items-center leading-[22px] whitespace-nowrap outline-none hover:whitespace-normal"
           }, {
-            default: l(() => [
-              k("p", H, R(F(u, t)), 1)
+            default: r(() => [
+              V("p", E, R(F(a, e)), 1)
             ]),
             _: 2
           }, 1032, ["aria-label"])
         ]),
         _: 2
-      }, 1024)) : m("", !0),
-      t?.description && !h.value ? (o(), v(i(c), { key: 1 }, {
-        default: l(() => [
-          n(i(I), {
-            "aria-label": t.description,
+      }, 1024)) : f("", !0),
+      e?.description && !C.value ? (l(), y(d(m), { key: 1 }, {
+        default: r(() => [
+          i(d(I), {
+            "aria-label": e.description,
             class: "max-h-[auto]"
           }, {
-            default: l(() => [
-              n(i(q), {
+            default: r(() => [
+              i(d(_), {
                 class: "auth-description bg-b-1 text-c-2 min-w-0 flex-1 px-3 py-1.25",
-                value: t.description
+                value: e.description
               }, null, 8, ["value"])
             ]),
             _: 2
           }, 1032, ["aria-label"])
         ]),
         _: 2
-      }, 1024)) : m("", !0),
-      t?.type === "http" ? (o(), s(d, { key: 2 }, [
-        t.scheme === "bearer" ? (o(), v(i(c), { key: 0 }, {
-          default: l(() => [
-            n(b, {
+      }, 1024)) : f("", !0),
+      e?.type === "http" ? (l(), u(c, { key: 2 }, [
+        e.scheme === "bearer" ? (l(), y(d(m), { key: 0 }, {
+          default: r(() => [
+            i(b, {
               containerClass: B(),
-              environment: r.environment,
-              modelValue: t["x-scalar-secret-token"],
+              environment: n.environment,
+              modelValue: e["x-scalar-secret-token"],
               placeholder: "Token",
               type: "password",
-              "onUpdate:modelValue": e[0] || (e[0] = (a) => g("x-scalar-secret-token", a))
+              "onUpdate:modelValue": (s) => h("x-scalar-secret-token", s, a)
             }, {
-              default: l(() => [...e[6] || (e[6] = [
-                y(" Bearer Token ", -1)
+              default: r(() => [...t[0] || (t[0] = [
+                v(" Bearer Token ", -1)
               ])]),
               _: 1
-            }, 8, ["containerClass", "environment", "modelValue"])
+            }, 8, ["containerClass", "environment", "modelValue", "onUpdate:modelValue"])
           ]),
           _: 2
-        }, 1024)) : t?.scheme === "basic" ? (o(), s(d, { key: 1 }, [
-          n(i(c), null, {
-            default: l(() => [
-              n(b, {
+        }, 1024)) : e?.scheme === "basic" ? (l(), u(c, { key: 1 }, [
+          i(d(m), null, {
+            default: r(() => [
+              i(b, {
                 class: "text-c-2",
-                environment: r.environment,
-                modelValue: t["x-scalar-secret-username"],
+                environment: n.environment,
+                modelValue: e["x-scalar-secret-username"],
                 placeholder: "janedoe",
                 required: "",
-                "onUpdate:modelValue": e[1] || (e[1] = (a) => g("x-scalar-secret-username", a))
+                "onUpdate:modelValue": (s) => h("x-scalar-secret-username", s, a)
               }, {
-                default: l(() => [...e[7] || (e[7] = [
-                  y(" Username ", -1)
+                default: r(() => [...t[1] || (t[1] = [
+                  v(" Username ", -1)
                 ])]),
                 _: 1
-              }, 8, ["environment", "modelValue"])
+              }, 8, ["environment", "modelValue", "onUpdate:modelValue"])
             ]),
             _: 2
           }, 1024),
-          n(i(c), null, {
-            default: l(() => [
-              n(b, {
-                environment: r.environment,
-                modelValue: t["x-scalar-secret-password"],
+          i(d(m), null, {
+            default: r(() => [
+              i(b, {
+                environment: n.environment,
+                modelValue: e["x-scalar-secret-password"],
                 placeholder: "********",
                 type: "password",
-                "onUpdate:modelValue": e[2] || (e[2] = (a) => g("x-scalar-secret-password", a))
+                "onUpdate:modelValue": (s) => h("x-scalar-secret-password", s, a)
               }, {
-                default: l(() => [...e[8] || (e[8] = [
-                  y(" Password ", -1)
+                default: r(() => [...t[2] || (t[2] = [
+                  v(" Password ", -1)
                 ])]),
                 _: 1
-              }, 8, ["environment", "modelValue"])
+              }, 8, ["environment", "modelValue", "onUpdate:modelValue"])
             ]),
             _: 2
           }, 1024)
-        ], 64)) : m("", !0)
-      ], 64)) : t?.type === "apiKey" ? (o(), s(d, { key: 3 }, [
-        n(i(c), null, {
-          default: l(() => [
-            n(b, {
+        ], 64)) : f("", !0)
+      ], 64)) : e?.type === "apiKey" ? (l(), u(c, { key: 3 }, [
+        i(d(m), null, {
+          default: r(() => [
+            i(b, {
               containerClass: B(),
-              environment: r.environment,
-              modelValue: t.name,
+              environment: n.environment,
+              modelValue: e.name,
               placeholder: "api-key",
-              "onUpdate:modelValue": e[3] || (e[3] = (a) => j("name", a))
+              "onUpdate:modelValue": (s) => j("name", s, a)
             }, {
-              default: l(() => [...e[9] || (e[9] = [
-                y(" Name ", -1)
+              default: r(() => [...t[3] || (t[3] = [
+                v(" Name ", -1)
               ])]),
               _: 1
-            }, 8, ["containerClass", "environment", "modelValue"])
+            }, 8, ["containerClass", "environment", "modelValue", "onUpdate:modelValue"])
           ]),
           _: 2
         }, 1024),
-        n(i(c), null, {
-          default: l(() => [
-            n(b, {
-              environment: r.environment,
-              modelValue: t["x-scalar-secret-token"],
+        i(d(m), null, {
+          default: r(() => [
+            i(b, {
+              environment: n.environment,
+              modelValue: e["x-scalar-secret-token"],
               placeholder: "QUxMIFlPVVIgQkFTRSBBUkUgQkVMT05HIFRPIFVT",
               type: "password",
-              "onUpdate:modelValue": e[4] || (e[4] = (a) => j("x-scalar-secret-token", a))
+              "onUpdate:modelValue": (s) => j("x-scalar-secret-token", s, a)
             }, {
-              default: l(() => [...e[10] || (e[10] = [
-                y(" Value ", -1)
+              default: r(() => [...t[4] || (t[4] = [
+                v(" Value ", -1)
               ])]),
               _: 1
-            }, 8, ["environment", "modelValue"])
+            }, 8, ["environment", "modelValue", "onUpdate:modelValue"])
           ]),
           _: 2
         }, 1024)
-      ], 64)) : t?.type === "oauth2" ? (o(), s(d, { key: 4 }, [
-        Object.keys(t.flows).length > 1 ? (o(), v(i(c), { key: 0 }, {
-          default: l(() => [
-            k("div", L, [
-              k("div", G, [
-                (o(!0), s(d, null, U(t.flows, (a, p, $) => (o(), s("button", {
+      ], 64)) : e?.type === "oauth2" ? (l(), u(c, { key: 4 }, [
+        Object.keys(e.flows).length > 1 ? (l(), y(d(m), { key: 0 }, {
+          default: r(() => [
+            V("div", H, [
+              V("div", L, [
+                (l(!0), u(c, null, g(e.flows, (s, p, U) => (l(), u("button", {
                   key: p,
-                  class: z(O(p, $)),
+                  class: z(O(p, U)),
                   type: "button",
                   onClick: (S) => w.value = p
                 }, [
-                  k("span", W, R(p), 1)
-                ], 10, J))), 128))
+                  V("span", J, R(p), 1)
+                ], 10, G))), 128))
               ])
             ])
           ]),
           _: 2
-        }, 1024)) : m("", !0),
-        (o(!0), s(d, null, U(t.flows, (a, p, $) => (o(), s(d, { key: p }, [
-          T(p, $) ? (o(), v(E, {
+        }, 1024)) : f("", !0),
+        (l(!0), u(c, null, g(e.flows, (s, p, U) => (l(), u(c, { key: p }, [
+          T(p, U) ? (l(), y(D, {
             key: 0,
-            environment: r.environment,
-            flows: t.flows,
-            proxyUrl: r.proxyUrl,
-            selectedScopes: V,
-            server: r.server,
+            environment: n.environment,
+            flows: e.flows,
+            proxyUrl: n.proxyUrl,
+            selectedScopes: k,
+            server: n.server,
             type: p,
-            "onUpdate:securityScheme": e[5] || (e[5] = (S) => x("update:securityScheme", S)),
-            "onUpdate:selectedScopes": (S) => M(u, S)
-          }, null, 8, ["environment", "flows", "proxyUrl", "selectedScopes", "server", "type", "onUpdate:selectedScopes"])) : m("", !0)
+            "onUpdate:securityScheme": (S) => x("update:securityScheme", S, a),
+            "onUpdate:selectedScopes": (S) => M(a, S)
+          }, null, 8, ["environment", "flows", "proxyUrl", "selectedScopes", "server", "type", "onUpdate:securityScheme", "onUpdate:selectedScopes"])) : f("", !0)
         ], 64))), 128))
-      ], 64)) : t?.type === "openIdConnect" ? (o(), s("div", {
+      ], 64)) : e?.type === "openIdConnect" ? (l(), u("div", {
         key: 5,
-        class: z(["text-c-3 bg-b-1 flex min-h-[calc(4rem+1px)] items-center justify-center border-t border-b-0 px-4 text-base", { "rounded-b-lg": r.isStatic }])
-      }, " Coming soon ", 2)) : m("", !0)
+        class: z(["text-c-3 bg-b-1 flex min-h-[calc(4rem+1px)] items-center justify-center border-t border-b-0 px-4 text-base", { "rounded-b-lg": n.isStatic }])
+      }, " Coming soon ", 2)) : f("", !0)
     ], 64))), 128));
   }
 });
 export {
-  oe as default
+  le as default
 };

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.d.ts

@@ -1,16 +1,5 @@
 import type { OAuthFlowsObject, ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 import type { ErrorResponse } from '../../../../libs/errors.js';
-/** Oauth2 security schemes which are not implicit */
-type NonImplicitFlows = Omit<OAuthFlowsObject, 'implicit'>;
-type PKCEState = {
-    codeVerifier: string;
-    codeChallenge: string;
-    codeChallengeMethod: string;
-};
-/**
- * Creates a code challenge from the code verifier
- */
-export declare const generateCodeChallenge: (verifier: string, encoding: "SHA-256" | "plain") => Promise<string>;
 /**
  * Authorize oauth2 flow
  *
@@ -21,14 +10,4 @@ export declare const authorizeOauth2: (flows: OAuthFlowsObject, type: keyof OAut
 activeServer: ServerObject | null, 
 /** If we want to use the proxy */
 proxyUrl: string) => Promise<ErrorResponse<string>>;
-/**
- * Makes the BE authorization call to grab the token server to server
- * Used for clientCredentials and authorizationCode
- */
-export declare const authorizeServers: (flows: NonImplicitFlows, type: keyof NonImplicitFlows, scopes: string, { code, pkce, proxyUrl, }: {
-    code?: string;
-    pkce?: PKCEState | null;
-    proxyUrl?: string;
-} | undefined, activeServer: ServerObject | null) => Promise<ErrorResponse<string>>;
-export {};
 //# sourceMappingURL=oauth.d.ts.map

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/oauth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGlH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,qDAAqD;AACrD,KAAK,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAA;AAE1D,KAAK,SAAS,GAAG;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,mBAAmB,EAAE,MAAM,CAAA;CAC5B,CAAA;AAgBD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAU,UAAU,MAAM,EAAE,UAAU,SAAS,GAAG,OAAO,KAAG,OAAO,CAAC,MAAM,CAkB3G,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,gBAAgB,EACvB,MAAM,MAAM,gBAAgB,EAC5B,gBAAgB,MAAM,EAAE;AACxB,wEAAwE;AACxE,cAAc,YAAY,GAAG,IAAI;AACjC,kCAAkC;AAClC,UAAU,MAAM,KACf,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAiL/B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,gBAAgB,EACvB,MAAM,MAAM,gBAAgB,EAC5B,QAAQ,MAAM,EACd,2BAIG;IACD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,YAAK,EACN,cAAc,YAAY,GAAG,IAAI,KAChC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAwF/B,CAAA"}
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/oauth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGlH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAgDlD;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,gBAAgB,EACvB,MAAM,MAAM,gBAAgB,EAC5B,gBAAgB,MAAM,EAAE;AACxB,wEAAwE;AACxE,cAAc,YAAY,GAAG,IAAI;AACjC,kCAAkC;AAClC,UAAU,MAAM,KACf,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAiL/B,CAAA"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.js

@@ -124,7 +124,5 @@ const S = () => {
   }
 };
 export {
-  L as authorizeOauth2,
-  U as authorizeServers,
-  z as generateCodeChallenge
+  L as authorizeOauth2
 };