@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-AO3F5XWR.js

@@ -0,0 +1,3147 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  WaitlistProducts,
+  WaitlistSources,
+  accessGroupSchema,
+  identityProviderRecordSchema,
+  identityProviders,
+  linkedRepositorySchema,
+  loginPortalSchema,
+  managedSchema,
+  managedSchemaVersion,
+  webhookDeliverySchema,
+  webhookSubscriptionSchema,
+  workspaceSchema,
+  workspaceVersionSchema
+} from "./chunk-HCPN3KNF.js";
+import {
+  userSchema
+} from "./chunk-B2MHTD3R.js";
+import {
+  sdkSchema
+} from "./chunk-3L6DLIXJ.js";
+import {
+  generateAccessByPersonalToken,
+  getAuthData,
+  refreshToken
+} from "./chunk-M37TP6U2.js";
+import {
+  config
+} from "./chunk-4ZDQXWBT.js";
+import {
+  UnifiedDocsMigrationStatus,
+  pendingInviteSchema,
+  teamBillingSummary,
+  teamImageSchema,
+  teamNameSchema,
+  teamSdkPricing,
+  userRefSchema
+} from "./chunk-VNYE4R7N.js";
+import {
+  docsProjectSchema,
+  githubInstallSchema,
+  githubProjectSchema,
+  projectSchema,
+  themeSchema
+} from "./chunk-OQKDBLOZ.js";
+import {
+  managedDocSchema,
+  managedDocVersionSchema,
+  ruleSchema
+} from "./chunk-CISTON3A.js";
+import {
+  docInstanceSchema,
+  docSourceSchema,
+  docVersionRecordSchema,
+  registryGitBindingSchema,
+  registryPublishRecordSchema
+} from "./chunk-Q7DOQHZN.js";
+import {
+  external_exports,
+  nanoid,
+  nanoidSchema,
+  schemaModel,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/service-api/dist/apis/access-groups.js
+function accessGroupsApiFactory(requestService) {
+  async function get(slug) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${slug}`,
+      method: "get",
+      schema: accessGroupSchema.pick({
+        uid: true,
+        name: true,
+        slug: true,
+        allowedDomains: true,
+        allowedEmails: true
+      })
+    });
+  }
+  async function create(data) {
+    return await requestService.request({
+      url: "core/v1/access-groups",
+      method: "post",
+      data,
+      schema: accessGroupSchema
+    });
+  }
+  async function del(uid) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${uid}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function update(uid, data) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${uid}`,
+      method: "patch",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function addEmail(uid, email) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${uid}/emails`,
+      method: "post",
+      data: { email },
+      schema: external_exports.null()
+    });
+  }
+  async function addDomain(uid, domain) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${uid}/domains`,
+      method: "post",
+      data: { domain },
+      schema: external_exports.null()
+    });
+  }
+  async function removeEmail(uid, email) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${uid}/emails`,
+      method: "delete",
+      data: { email },
+      schema: external_exports.null()
+    });
+  }
+  async function removeDomain(uid, domain) {
+    return await requestService.request({
+      url: `core/v1/access-groups/${uid}/domains`,
+      method: "delete",
+      data: { domain },
+      schema: external_exports.null()
+    });
+  }
+  return {
+    get,
+    create,
+    update,
+    delete: del,
+    addEmail,
+    addDomain,
+    removeEmail,
+    removeDomain
+  };
+}
+
+// ../../packages/bigquery/dist/schemas.js
+var consumerTypeSchema = external_exports.enum(["human", "bot", "llm", "mcp"]);
+var timeseriesPointSchema = external_exports.object({
+  bucket: external_exports.string(),
+  human: external_exports.number().int().nonnegative(),
+  bot: external_exports.number().int().nonnegative(),
+  llm: external_exports.number().int().nonnegative(),
+  unique: external_exports.number().int().nonnegative()
+});
+var overviewResultSchema = external_exports.object({
+  totals: external_exports.object({
+    views: external_exports.number().int().nonnegative(),
+    peak_daily_visitors: external_exports.number().int().nonnegative(),
+    human: external_exports.number().int().nonnegative(),
+    bot: external_exports.number().int().nonnegative(),
+    llm: external_exports.number().int().nonnegative(),
+    mcp: external_exports.number().int().nonnegative()
+  }),
+  timeseries: external_exports.array(timeseriesPointSchema)
+});
+var topPageSchema = external_exports.object({
+  path: external_exports.string(),
+  views: external_exports.number().int().nonnegative(),
+  unique: external_exports.number().int().nonnegative()
+});
+var topPagesResultSchema = external_exports.object({
+  pages: external_exports.array(topPageSchema)
+});
+var topReferrerSchema = external_exports.object({
+  referrer: external_exports.string(),
+  views: external_exports.number().int().nonnegative()
+});
+var topReferrersResultSchema = external_exports.object({
+  referrers: external_exports.array(topReferrerSchema)
+});
+var consumersResultSchema = external_exports.object({
+  totals: external_exports.object({
+    human: external_exports.number().int().nonnegative(),
+    bot: external_exports.number().int().nonnegative(),
+    llm: external_exports.number().int().nonnegative()
+  }),
+  timeseries: external_exports.array(timeseriesPointSchema)
+});
+var mcpEventKindSchema = external_exports.enum([
+  "session-start",
+  "tool-called",
+  "tools-list"
+]);
+
+// ../../packages/service-api/dist/apis/analytics.js
+function buildQuery(params) {
+  const search = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0)
+      continue;
+    search.set(k, String(v));
+  }
+  const qs = search.toString();
+  return qs ? `?${qs}` : "";
+}
+function analyticsApiFactory(requestService) {
+  async function getOverview(projectUid, args = {}) {
+    return requestService.request({
+      url: `core/analytics/projects/${projectUid}/overview${buildQuery({
+        range: args.range,
+        granularity: args.granularity
+      })}`,
+      method: "get",
+      schema: overviewResultSchema
+    });
+  }
+  async function getPages(projectUid, args = {}) {
+    return requestService.request({
+      url: `core/analytics/projects/${projectUid}/pages${buildQuery({
+        range: args.range,
+        limit: args.limit
+      })}`,
+      method: "get",
+      schema: topPagesResultSchema
+    });
+  }
+  async function getReferrers(projectUid, args = {}) {
+    return requestService.request({
+      url: `core/analytics/projects/${projectUid}/referrers${buildQuery({
+        range: args.range,
+        limit: args.limit
+      })}`,
+      method: "get",
+      schema: topReferrersResultSchema
+    });
+  }
+  async function getConsumers(projectUid, args = {}) {
+    return requestService.request({
+      url: `core/analytics/projects/${projectUid}/consumers${buildQuery({
+        range: args.range,
+        granularity: args.granularity
+      })}`,
+      method: "get",
+      schema: consumersResultSchema
+    });
+  }
+  return {
+    getOverview,
+    getPages,
+    getReferrers,
+    getConsumers
+  };
+}
+
+// ../../packages/service-api/dist/apis/login-portals.js
+function loginPortalsApiFactory(requestService) {
+  async function get(slug) {
+    return await requestService.request({
+      url: `core/login-portals/${slug}`,
+      method: "get",
+      schema: loginPortalSchema
+    });
+  }
+  async function create(data) {
+    return await requestService.request({
+      url: "core/login-portals",
+      method: "post",
+      data,
+      schema: external_exports.object({ uid: external_exports.string() })
+    });
+  }
+  async function update(data) {
+    return await requestService.request({
+      url: "core/login-portals/update",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function del(slug) {
+    return await requestService.request({
+      url: "core/login-portals",
+      data: { slug },
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function getLoginPortals() {
+    return await requestService.request({
+      url: "core/login-portals",
+      method: "get",
+      schema: loginPortalSchema.pick({
+        uid: true,
+        title: true,
+        slug: true
+      }).array()
+    });
+  }
+  return {
+    /** Get a login portal by namespace/slug combination */
+    get,
+    /** Creates a new login portal */
+    create,
+    /** Update login portal metadata */
+    update,
+    /** Delete a login portal and remove any associates to projects or docs */
+    delete: del,
+    /** Get a list of all login portal related to the namespace */
+    getLoginPortals
+  };
+}
+
+// ../../packages/service-api/dist/apis/minify-json.js
+var SPACE = 32;
+var TAB = 9;
+var LINE_FEED = 10;
+var CARRIAGE_RETURN = 13;
+var QUOTE = 34;
+var BACKSLASH = 92;
+function isInsignificantWhitespace(code) {
+  return code === SPACE || code === TAB || code === LINE_FEED || code === CARRIAGE_RETURN;
+}
+function minifyJson(json) {
+  const kept = [];
+  let keptFrom = 0;
+  let index = 0;
+  let inString = false;
+  while (index < json.length) {
+    const code = json.charCodeAt(index);
+    if (inString) {
+      if (code === BACKSLASH)
+        index++;
+      else if (code === QUOTE)
+        inString = false;
+      index++;
+      continue;
+    }
+    if (code === QUOTE) {
+      inString = true;
+      index++;
+      continue;
+    }
+    if (isInsignificantWhitespace(code)) {
+      kept.push(json.slice(keptFrom, index));
+      do
+        index++;
+      while (index < json.length && isInsignificantWhitespace(json.charCodeAt(index)));
+      keptFrom = index;
+      continue;
+    }
+    index++;
+  }
+  if (keptFrom === 0)
+    return json;
+  kept.push(json.slice(keptFrom));
+  return kept.join("");
+}
+
+// ../../packages/service-api/dist/apis/compact-publish-body.js
+var PUBLISH_BODY_LIMIT_BYTES = 2e7;
+function encodedBytes(value) {
+  return new TextEncoder().encode(value).length;
+}
+function compactPublishBody(body) {
+  try {
+    if (encodedBytes(JSON.stringify(body)) <= PUBLISH_BODY_LIMIT_BYTES)
+      return { body, minified: false };
+    JSON.parse(body.document);
+    const document2 = minifyJson(body.document);
+    return document2.length < body.document.length ? { body: { ...body, document: document2 }, minified: true } : { body, minified: false };
+  } catch {
+    return { body, minified: false };
+  }
+}
+
+// ../../packages/service-api/dist/apis/managed-docs.js
+function managedDocsApiFactory(requestService) {
+  async function get(namespace, slug, semver, options) {
+    const query = options?.variant ? `?variant=${options.variant}` : "";
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}/version/${semver}${query}`,
+      method: "get",
+      schema: external_exports.string()
+    });
+  }
+  async function getVersionMetadata(namespace, slug, semver) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}/version/${semver}/metadata`,
+      method: "get",
+      schema: managedDocVersionSchema
+    });
+  }
+  async function getApiDocs(namespace) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}`,
+      method: "get",
+      schema: managedDocSchema.pick({
+        uid: true,
+        version: true,
+        title: true,
+        slug: true,
+        description: true,
+        namespace: true,
+        isPrivate: true,
+        tags: true
+      }).extend({ versions: managedDocVersionSchema.array() }).array()
+    });
+  }
+  async function getApiDoc(namespace, slug) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}`,
+      method: "get",
+      schema: managedDocSchema.pick({
+        uid: true,
+        version: true,
+        title: true,
+        slug: true,
+        description: true,
+        namespace: true,
+        isPrivate: true,
+        tags: true
+      }).extend({ versions: managedDocVersionSchema.array() })
+    });
+  }
+  async function listApiDocs() {
+    return await requestService.request({
+      url: "core/managed-doc",
+      method: "get",
+      schema: managedDocSchema.pick({
+        uid: true,
+        version: true,
+        title: true,
+        slug: true,
+        description: true,
+        namespace: true,
+        isPrivate: true,
+        tags: true
+      }).extend({ versions: managedDocVersionSchema.array() }).array()
+    });
+  }
+  async function create(namespace, data, options) {
+    const { body, minified } = compactPublishBody(data);
+    if (minified)
+      options?.onCompacted?.();
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}`,
+      method: "post",
+      data: body,
+      schema: external_exports.object({
+        uid: external_exports.string(),
+        versionUid: external_exports.string(),
+        title: external_exports.string(),
+        jsonSha: external_exports.string(),
+        yamlSha: external_exports.string()
+      })
+    });
+  }
+  async function update(namespace, slug, data) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}`,
+      method: "patch",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function addVersion(namespace, slug, data, options) {
+    const { body, minified } = compactPublishBody(data);
+    if (minified)
+      options?.onCompacted?.();
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}/version`,
+      method: "post",
+      data: body,
+      schema: managedDocVersionSchema
+    });
+  }
+  async function updateVersion(namespace, slug, semver, data, options) {
+    const { body, minified } = compactPublishBody(data);
+    if (minified)
+      options?.onCompacted?.();
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}/version/${semver}`,
+      method: "patch",
+      data: body,
+      schema: external_exports.object({
+        jsonSha: external_exports.string(),
+        yamlSha: external_exports.string()
+      })
+    });
+  }
+  async function deleteVersion(namespace, slug, semver) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}/version/${semver}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function addAccessGroup(data) {
+    return await requestService.request({
+      url: "core/managed-doc/access-group",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeAccessGroup(data) {
+    return await requestService.request({
+      url: "core/managed-doc/access-group",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function addSdk(data) {
+    return await requestService.request({
+      url: "core/v1/documents/sdk",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  3;
+  async function removeSdk(data) {
+    return await requestService.request({
+      url: "core/v1/documents/sdk",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function deleteDoc(namespace, slug) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function isRegistrySlugAvailable(data) {
+    return await requestService.request({
+      url: "core/managed-doc/available",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        available: external_exports.boolean()
+      })
+    });
+  }
+  async function updateMcpTools({ namespace, slug, semver, tools }) {
+    return await requestService.request({
+      url: `core/managed-doc/${namespace}/${slug}/version/${semver}/tools`,
+      method: "post",
+      data: tools,
+      schema: external_exports.null()
+    });
+  }
+  return {
+    getApiDocs,
+    listApiDocs,
+    get,
+    getVersionMetadata,
+    create,
+    update,
+    delete: deleteDoc,
+    addVersion,
+    addSdk,
+    removeSdk,
+    updateVersion,
+    deleteVersion,
+    addAccessGroup,
+    removeAccessGroup,
+    isRegistrySlugAvailable,
+    getApiDoc,
+    updateMcpTools
+  };
+}
+
+// ../../packages/service-api/dist/apis/managed-schemas.js
+function managedSchemasApiFactory(requestService) {
+  async function getSchemas(namespace) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}`,
+      method: "get",
+      schema: managedSchema.pick({
+        uid: true,
+        title: true,
+        description: true,
+        slug: true,
+        namespace: true,
+        isPrivate: true
+      }).extend({ versions: managedSchemaVersion.array() }).array()
+    });
+  }
+  async function create(namespace, data) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}`,
+      method: "post",
+      data,
+      schema: external_exports.object({ uid: external_exports.string() })
+    });
+  }
+  async function update(namespace, slug, data) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}`,
+      method: "patch",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function del(namespace, slug) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function get(namespace, slug, version) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}/version/${version}`,
+      method: "get",
+      schema: external_exports.string()
+    });
+  }
+  async function createVersion(namespace, slug, data) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}/version`,
+      method: "post",
+      data,
+      schema: external_exports.object({
+        uid: external_exports.string()
+      })
+    });
+  }
+  async function duplicateVersion(namespace, slug, version, data) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}/version/${version}/duplicate`,
+      method: "post",
+      data,
+      schema: external_exports.object({ uid: external_exports.string() })
+    });
+  }
+  async function updateVersion(namespace, slug, version, data) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}/version/${version}`,
+      method: "post",
+      data,
+      schema: external_exports.object({ jsonSha: external_exports.string() })
+    });
+  }
+  async function deleteVersion(namespace, slug, version) {
+    return await requestService.request({
+      url: `core/schemas/${namespace}/${slug}/version/${version}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function isRegistrySlugAvailable(namespace, slug) {
+    return await requestService.request({
+      url: "core/schemas/check-slug",
+      method: "post",
+      data: {
+        namespace,
+        slug
+      },
+      schema: external_exports.object({
+        available: external_exports.boolean()
+      })
+    });
+  }
+  async function addAccessGroup(data) {
+    return await requestService.request({
+      url: "core/schemas/access-group",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeAccessGroup(data) {
+    return await requestService.request({
+      url: "core/schemas/access-group",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  return {
+    getSchemas,
+    create,
+    update,
+    delete: del,
+    get,
+    createVersion,
+    duplicateVersion,
+    updateVersion,
+    deleteVersion,
+    isRegistrySlugAvailable,
+    addAccessGroup,
+    removeAccessGroup
+  };
+}
+
+// ../../packages/service-api/dist/apis/registry-git.js
+var commitSchema = external_exports.object({
+  sha: external_exports.string(),
+  message: external_exports.string(),
+  authorName: external_exports.string(),
+  authorEmail: external_exports.string(),
+  timestamp: external_exports.number()
+});
+function registryGitApiFactory(requestService) {
+  const base = (asset, namespace, slug) => `core/registry-git/${asset}/${namespace}/${slug}`;
+  async function provision(asset, namespace, slug) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/provision`,
+      method: "post",
+      data: {},
+      schema: external_exports.object({
+        git: registryGitBindingSchema.nullable(),
+        status: external_exports.enum(["migrated", "already-migrated", "partial"]),
+        versionsImported: external_exports.number(),
+        versionsSkipped: external_exports.number()
+      })
+    });
+  }
+  async function getHistory(asset, namespace, slug, opts) {
+    const query = new URLSearchParams();
+    if (opts?.page)
+      query.set("page", String(opts.page));
+    if (opts?.perPage)
+      query.set("perPage", String(opts.perPage));
+    const qs = query.toString();
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/history${qs ? `?${qs}` : ""}`,
+      method: "get",
+      schema: external_exports.object({ commits: commitSchema.array() })
+    });
+  }
+  async function getPublishLog(asset, namespace, slug) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/publishes`,
+      method: "get",
+      schema: external_exports.object({ publishes: registryPublishRecordSchema.array() })
+    });
+  }
+  async function publish(asset, namespace, slug, data) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/publish`,
+      method: "post",
+      data: data ?? {},
+      schema: external_exports.object({
+        commitSha: external_exports.string(),
+        version: external_exports.string().nullable()
+      })
+    });
+  }
+  async function updateConfig(asset, namespace, slug, data) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/config`,
+      method: "patch",
+      data,
+      schema: external_exports.object({ source: docSourceSchema })
+    });
+  }
+  async function linkExternal(asset, namespace, slug, data) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/link-external`,
+      method: "post",
+      data,
+      schema: external_exports.object({
+        repository: linkedRepositorySchema,
+        source: docSourceSchema,
+        pullRequest: external_exports.object({
+          url: external_exports.string(),
+          number: external_exports.number(),
+          branch: external_exports.string()
+        })
+      })
+    });
+  }
+  async function unlinkExternal(asset, namespace, slug) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/unlink-external`,
+      method: "post",
+      data: {},
+      schema: external_exports.object({ source: docSourceSchema })
+    });
+  }
+  async function proposeEdit(asset, namespace, slug, data) {
+    return await requestService.request({
+      url: `core/registry-git/${asset}/${namespace}/${slug}/propose`,
+      method: "post",
+      data,
+      schema: external_exports.object({
+        prNumber: external_exports.number(),
+        prUrl: external_exports.string(),
+        branch: external_exports.string()
+      })
+    });
+  }
+  async function getSource(asset, namespace, slug, opts) {
+    const qs = opts?.branch ? `?branch=${encodeURIComponent(opts.branch)}` : "";
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/source${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        source: docSourceSchema.nullable(),
+        repository: linkedRepositorySchema.nullable(),
+        openProposal: external_exports.object({ prNumber: external_exports.number(), branch: external_exports.string() }).nullable()
+      })
+    });
+  }
+  async function listBranches(asset, namespace, slug) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/branches`,
+      method: "get",
+      schema: external_exports.object({
+        branches: external_exports.object({ name: external_exports.string(), sha: external_exports.string() }).array(),
+        trackedBranch: external_exports.string()
+      })
+    });
+  }
+  async function createBranch(asset, namespace, slug, data) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/branches`,
+      method: "post",
+      data,
+      schema: external_exports.object({ name: external_exports.string(), sha: external_exports.string() })
+    });
+  }
+  async function getFile(asset, namespace, slug, opts) {
+    const qs = opts?.ref ? `?ref=${encodeURIComponent(opts.ref)}` : "";
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/file${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        content: external_exports.string(),
+        sha: external_exports.string(),
+        ref: external_exports.string()
+      })
+    });
+  }
+  return {
+    proposeEdit,
+    provision,
+    getHistory,
+    getPublishLog,
+    getSource,
+    getFile,
+    listBranches,
+    createBranch,
+    publish,
+    updateConfig,
+    linkExternal,
+    unlinkExternal
+  };
+}
+
+// ../../packages/service-api/dist/apis/registry-instances.js
+var registryVersionRecordSchema = docVersionRecordSchema.extend({
+  /** The content the label serves; null while it has no serving history (no instances, or only drafts). */
+  jsonSha: external_exports.string().nullable(),
+  yamlSha: external_exports.string().nullable()
+});
+function registryInstancesApiFactory(requestService) {
+  const base = (asset, namespace, slug) => `core/registry/${asset}/${namespace}/${slug}`;
+  async function listInstances(asset, namespace, slug, opts) {
+    const query = new URLSearchParams();
+    if (opts?.version)
+      query.set("version", opts.version);
+    if (opts?.page != null)
+      query.set("page", String(opts.page));
+    if (opts?.perPage != null)
+      query.set("perPage", String(opts.perPage));
+    const qs = query.toString();
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/instances${qs ? `?${qs}` : ""}`,
+      method: "get",
+      schema: external_exports.object({
+        instances: docInstanceSchema.array(),
+        tracked: external_exports.boolean()
+      })
+    });
+  }
+  async function listVersions(asset, namespace, slug) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/versions`,
+      method: "get",
+      schema: external_exports.object({ versions: registryVersionRecordSchema.array() })
+    });
+  }
+  async function getInstanceContent(asset, namespace, slug, jsonSha, opts) {
+    const query = new URLSearchParams();
+    if (opts?.format)
+      query.set("format", opts.format);
+    const qs = query.toString();
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/instances/${jsonSha}/content${qs ? `?${qs}` : ""}`,
+      method: "get",
+      schema: external_exports.object({
+        content: external_exports.string(),
+        format: external_exports.enum(["json", "yaml"]),
+        jsonSha: external_exports.string()
+      })
+    });
+  }
+  async function setActiveInstance(asset, namespace, slug, version, instanceUid) {
+    return await requestService.request({
+      url: `${base(asset, namespace, slug)}/versions/${encodeURIComponent(version)}/active`,
+      method: "post",
+      data: { instanceUid },
+      schema: external_exports.object({
+        jsonSha: external_exports.string(),
+        changed: external_exports.boolean()
+      })
+    });
+  }
+  return {
+    listInstances,
+    listVersions,
+    getInstanceContent,
+    setActiveInstance
+  };
+}
+
+// ../../packages/service-api/dist/apis/rules.js
+function rulesApiFactory(requestService) {
+  async function get(namespace, slug) {
+    return await requestService.request({
+      url: `core/rulesets/${namespace}/${slug}`,
+      method: "get",
+      schema: external_exports.string()
+    });
+  }
+  async function getRules(namespace) {
+    return await requestService.request({
+      url: `core/rulesets/${namespace}`,
+      method: "get",
+      schema: ruleSchema.pick({
+        uid: true,
+        title: true,
+        description: true,
+        slug: true,
+        namespace: true,
+        isPrivate: true,
+        blockPublishOn: true
+      }).array()
+    });
+  }
+  async function create(namespace, data) {
+    return await requestService.request({
+      url: `core/rulesets/${namespace}`,
+      method: "post",
+      data,
+      schema: external_exports.object({ uid: external_exports.string() })
+    });
+  }
+  async function upload(data) {
+    return await requestService.request({
+      url: "core/rulesets/upload",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function update(namespace, slug, data) {
+    return await requestService.request({
+      url: `core/rulesets/${namespace}/${slug}`,
+      method: "patch",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function del(namespace, slug) {
+    return await requestService.request({
+      url: `core/rulesets/${namespace}/${slug}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function addAccessGroup(data) {
+    return await requestService.request({
+      url: "core/rules/access-group",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeAccessGroup(data) {
+    return await requestService.request({
+      url: "core/rules/access-group",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function isRegistrySlugAvailable(namespace, slug) {
+    return await requestService.request({
+      url: "core/rulesets/check-slug",
+      method: "post",
+      data: {
+        namespace,
+        slug
+      },
+      schema: external_exports.object({
+        available: external_exports.boolean()
+      })
+    });
+  }
+  return {
+    get,
+    getRules,
+    create,
+    update,
+    delete: del,
+    upload,
+    addAccessGroup,
+    removeAccessGroup,
+    isRegistrySlugAvailable
+  };
+}
+
+// ../../packages/service-api/dist/apis/sdks.js
+function sdksApiFactory(requestService) {
+  async function list(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    const suffix = query.size ? `?${query.toString()}` : "";
+    return await requestService.request({
+      url: `core/v1/sdks${suffix}`,
+      method: "get",
+      schema: external_exports.object({
+        data: sdkSchema.array(),
+        hasMore: external_exports.boolean()
+      })
+    });
+  }
+  async function get(uid) {
+    return await requestService.request({
+      url: `core/v1/sdks/${uid}`,
+      method: "get",
+      schema: sdkSchema
+    });
+  }
+  async function create(data) {
+    return await requestService.request({
+      url: "core/v1/sdks",
+      method: "post",
+      data,
+      schema: external_exports.string()
+    });
+  }
+  async function update(uid, data) {
+    return await requestService.request({
+      url: `core/v1/sdks/${uid}`,
+      method: "patch",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function createVersion(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/version",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function previewCodeSamples(data) {
+    const { signal, ...body } = data;
+    return await requestService.request({
+      url: "sdk-generator/preview",
+      method: "post",
+      data: body,
+      schema: external_exports.unknown(),
+      signal
+    });
+  }
+  async function resolveConfig(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/resolve-config",
+      method: "post",
+      data,
+      schema: external_exports.object({ config: external_exports.string() })
+    });
+  }
+  async function transformConfig(data) {
+    return await requestService.request({
+      url: "sdk-generator/transform-config",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        config: external_exports.string().nullable()
+      })
+    });
+  }
+  async function del(uid) {
+    return await requestService.request({
+      url: `core/v1/sdks/${uid}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function discardDraft(uid) {
+    return await requestService.request({
+      url: `core/v1/sdks/${uid}/draft`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function deleteVersion(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/version",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function available(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/available",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        available: external_exports.boolean()
+      })
+    });
+  }
+  async function checkRegistryAvailability(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/registry/availability",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        /** The registry that was asked, or `null` when the language has none. */
+        registry: external_exports.string().nullable(),
+        status: external_exports.enum(["available", "taken", "unsupported", "invalid"])
+      })
+    });
+  }
+  async function addAccessGroup(uid, data) {
+    return await requestService.request({
+      url: `core/v1/sdks/${uid}/access-group`,
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeAccessGroup(uid, data) {
+    return await requestService.request({
+      url: `core/v1/sdks/${uid}/access-group`,
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function linkRepo(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/repository",
+      method: "post",
+      data,
+      // The resolved "owner/repo" + branch, so the editor can mirror the
+      // destination into the project config (the source of truth). Nullable to
+      // tolerate a deploy-skew window where core still returns the old `null`
+      // body: the mirror is skipped rather than surfacing a false link error
+      // (the server already wrote the destination into the config regardless).
+      schema: external_exports.object({ repo: external_exports.string(), branch: external_exports.string() }).nullable()
+    });
+  }
+  async function requestSampleAccess(data) {
+    return await requestService.request({
+      url: `core/v1/sdks/${data.uid}/sample/access`,
+      method: "post",
+      data: { language: data.language },
+      schema: external_exports.object({
+        repositories: external_exports.object({
+          /** Where the repo lives in the server's org, not on the binding. */
+          repository: external_exports.string(),
+          invitationUrl: external_exports.string().nullable(),
+          /** Why GitHub refused. Only `missing` can be repaired by a retry. */
+          failure: external_exports.enum(["missing", "forbidden", "unavailable"]).optional()
+        }).array()
+      })
+    });
+  }
+  const retrySampleRepos = async (data) => {
+    return await requestService.request({
+      url: `core/v1/sdks/${data.uid}/sample/retry`,
+      method: "post",
+      data: { language: data.language },
+      schema: external_exports.null()
+    });
+  };
+  async function updateRepo(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/repository/update",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  const getReleasePr = async (params) => {
+    const query = new URLSearchParams({
+      uid: params.uid,
+      language: params.language
+    });
+    return await requestService.request({
+      url: `core/v1/sdks/repository/release-pr?${query.toString()}`,
+      method: "get",
+      schema: external_exports.object({ pullRequest: external_exports.number().nullable() })
+    });
+  };
+  async function unlinkRepo(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/repository",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function updatePublishing(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/repository/publishing",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function syncBuild(data) {
+    return await requestService.request({
+      url: "core/v1/sdks/sync",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function build(sdkUid, version, languages) {
+    return await requestService.request({
+      url: "core/v1/sdks/build",
+      method: "post",
+      data: { sdkUid, version, languages },
+      // Non-null exactly when `version` was omitted: the version the server
+      // resolved and is building.
+      schema: external_exports.object({ version: external_exports.string() }).nullable()
+    });
+  }
+  return {
+    list,
+    get,
+    create,
+    createVersion,
+    previewCodeSamples,
+    resolveConfig,
+    transformConfig,
+    update,
+    delete: del,
+    discardDraft,
+    deleteVersion,
+    available,
+    checkRegistryAvailability,
+    addAccessGroup,
+    removeAccessGroup,
+    getReleasePr,
+    linkRepo,
+    requestSampleAccess,
+    retrySampleRepos,
+    unlinkRepo,
+    updateRepo,
+    updatePublishing,
+    build,
+    syncBuild
+  };
+}
+
+// ../../packages/service-api/dist/apis/themes.js
+function themesApiFactory(requestService) {
+  async function get(slug) {
+    return await requestService.request({
+      url: `core/themes/${slug}`,
+      method: "get",
+      schema: external_exports.string()
+    });
+  }
+  async function getThemes() {
+    return await requestService.request({
+      url: "core/themes",
+      method: "get",
+      schema: themeSchema.pick({
+        uid: true,
+        name: true,
+        description: true,
+        slug: true
+      }).array()
+    });
+  }
+  async function create(data) {
+    return await requestService.request({
+      url: "core/themes",
+      method: "post",
+      data,
+      schema: external_exports.object({ uid: external_exports.string(), slug: slugSchema })
+    });
+  }
+  async function replace(slug, data) {
+    return await requestService.request({
+      url: `core/themes/${slug}`,
+      method: "put",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function update(slug, data) {
+    return await requestService.request({
+      url: `core/themes/${slug}`,
+      method: "patch",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function del(slug) {
+    return await requestService.request({
+      url: `core/themes/${slug}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  return {
+    get,
+    getThemes,
+    create,
+    update,
+    replace,
+    delete: del
+  };
+}
+
+// ../../packages/service-api/dist/apis/user.js
+function userApiFactory(requestService) {
+  async function update(data) {
+    return await requestService.request({
+      url: "core/user/update",
+      method: "post",
+      schema: external_exports.null(),
+      data
+    });
+  }
+  async function getMe() {
+    return await requestService.request({
+      url: "core/me",
+      method: "get",
+      schema: userSchema
+    });
+  }
+  return { update, getMe };
+}
+
+// ../../packages/service-api/dist/apis/waitlist.js
+function waitlistApiFactory(requestService) {
+  async function addToClientWaitlist(email, metadata) {
+    return await requestService.request({
+      url: "core/waitlist",
+      method: "post",
+      data: { email, products: [WaitlistProducts.Client], metadata },
+      headers: {
+        /** Source application. Will be used for header based filtering server side */
+        "x-scalar-product": WaitlistSources.Client
+      },
+      schema: external_exports.null()
+    });
+  }
+  return {
+    addToClientWaitlist
+  };
+}
+
+// ../../packages/service-api/dist/apis/webhooks.js
+var subscriptionSchema = webhookSubscriptionSchema.omit({ teamUid: true });
+var deliverySchema = webhookDeliverySchema.omit({ teamUid: true });
+var webhooksApiFactory = (requestService) => {
+  const create = async (data) => {
+    return await requestService.request({
+      url: "core/v1/webhooks",
+      method: "post",
+      data,
+      schema: subscriptionSchema.extend({ secret: external_exports.string() })
+    });
+  };
+  const update = async (uid, data) => {
+    return await requestService.request({
+      url: `core/v1/webhooks/${uid}`,
+      method: "patch",
+      data,
+      schema: subscriptionSchema
+    });
+  };
+  const rotateSecret = async (uid, data) => {
+    return await requestService.request({
+      url: `core/v1/webhooks/${uid}/secret`,
+      method: "post",
+      data: data ?? {},
+      schema: external_exports.object({
+        secret: external_exports.string(),
+        /**
+         * When the replaced secret stops signing, or null when it already has.
+         * A routine roll leaves the old key valid for a grace window so the
+         * receiver can be updated without dropping deliveries.
+         */
+        previousSecretExpiresAt: external_exports.number().nullable()
+      })
+    });
+  };
+  const del = async (uid) => {
+    return await requestService.request({
+      url: `core/v1/webhooks/${uid}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  };
+  const deliveries = async (uid) => {
+    return await requestService.request({
+      url: `core/v1/webhooks/${uid}/deliveries`,
+      method: "get",
+      schema: deliverySchema.array()
+    });
+  };
+  const deliveryCounts = async () => {
+    return await requestService.request({
+      url: "core/v1/webhooks/delivery-counts",
+      method: "get",
+      schema: external_exports.object({
+        subscriptionUid: webhookSubscriptionSchema.shape.uid,
+        count: external_exports.number()
+      }).array()
+    });
+  };
+  const test = async (uid) => {
+    return await requestService.request({
+      url: `core/v1/webhooks/${uid}/test`,
+      method: "post",
+      schema: external_exports.object({ scheduled: external_exports.number() })
+    });
+  };
+  return {
+    create,
+    update,
+    delete: del,
+    rotateSecret,
+    deliveries,
+    deliveryCounts,
+    test
+  };
+};
+
+// ../../packages/service-api/dist/apis/workspace.js
+function workspaceApiFactory(requestService) {
+  async function createWorkspace(namespace, data) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}`,
+      method: "post",
+      data,
+      schema: workspaceSchema
+    });
+  }
+  async function updateWorkspace(namespace, slug, data) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}`,
+      method: "patch",
+      data,
+      schema: workspaceSchema
+    });
+  }
+  async function deleteWorkspace(namespace, slug) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function deleteWorkspaceVersion(namespace, slug, version) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}/version/${version}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function versionWorkspace(namespace, slug, data) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}/version`,
+      method: "post",
+      data,
+      schema: workspaceVersionSchema
+    });
+  }
+  async function addWorkspaceAccess(namespace, slug, group) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}/access/${group}`,
+      method: "post",
+      schema: external_exports.null()
+    });
+  }
+  async function removeWorkspaceAccess(namespace, slug, group) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}/access/${group}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function workspaceAvailability(namespace, slug) {
+    return await requestService.request({
+      url: `core/workspaces/${namespace}/${slug}/available`,
+      method: "get",
+      schema: external_exports.object({ available: external_exports.boolean() })
+    });
+  }
+  return {
+    createWorkspace,
+    updateWorkspace,
+    deleteWorkspace,
+    versionWorkspace,
+    addWorkspaceAccess,
+    removeWorkspaceAccess,
+    workspaceAvailability,
+    deleteWorkspaceVersion
+  };
+}
+
+// ../../packages/service-api/dist/request.js
+function formatApiResponse(data, status, headers) {
+  return {
+    status,
+    data,
+    headers,
+    error: false
+  };
+}
+function formatApiError(message, status, error = null, code, body) {
+  return {
+    status,
+    message,
+    error: true,
+    originalError: error,
+    code,
+    body
+  };
+}
+var UNDICI_TIMEOUT_ERRORS = /* @__PURE__ */ new Set([
+  "HeadersTimeoutError",
+  "BodyTimeoutError"
+]);
+function isDeadlineError(err) {
+  if (err.name === "TimeoutError")
+    return true;
+  const cause = err.cause;
+  if (!(cause instanceof Error))
+    return false;
+  return cause.name === "TimeoutError" || UNDICI_TIMEOUT_ERRORS.has(cause.name);
+}
+function requestServiceFactory(baseUrl, getAuthToken, logger = console) {
+  async function request({ disableAuth = false, url: requestUrl, schema, data, stream, ...config2 }) {
+    const headers = {};
+    for (const headerKey in config2.headers) {
+      if (Object.hasOwn(config2.headers, headerKey)) {
+        headers[headerKey.toLowerCase()] = config2.headers[headerKey];
+      }
+    }
+    if (!("content-type" in headers) && data)
+      headers["content-type"] = "application/json";
+    if (data instanceof FormData)
+      delete headers["content-type"];
+    if (!disableAuth && (getAuthToken || config2.token)) {
+      const token = (getAuthToken ? getAuthToken() : config2.token)?.trim();
+      if (token) {
+        headers.authorization = `Bearer ${token}`;
+      } else {
+        logger.warn("WARNING: Auth token function returned an empty value");
+      }
+    }
+    const url = (/^https?:\/\//i.test(requestUrl) ? requestUrl : `${baseUrl}/${requestUrl}`).replace(/([^:]\/)\/+/g, "$1");
+    const method = config2.method === "patch" ? "PATCH" : config2.method;
+    return fetch(url, {
+      ...config2,
+      credentials: "include",
+      method,
+      body: data instanceof FormData || data instanceof ReadableStream || data === void 0 ? data : JSON.stringify(data),
+      headers,
+      ...data instanceof ReadableStream && {
+        duplex: "half"
+      }
+    }).then(async (response) => {
+      const isJson = response.headers.get("content-type")?.includes("application/json");
+      if (!response.ok) {
+        const body = isJson ? await response.json().catch(() => ({ message: "Invalid response" })) : { message: await response.text().catch(() => "Invalid response") };
+        const message = String(body.message ?? "") || "Unknown Error";
+        const code = typeof body.code === "string" ? body.code : void 0;
+        return formatApiError(message, response.status, null, code, body);
+      }
+      if (stream)
+        return response.body ?? new ReadableStream();
+      try {
+        const baseData = response.ok && isJson ? await response.json().catch(() => {
+          logger.error(`Invalid JSON response from API service from ${url}`);
+          return null;
+        }) : await response.text();
+        const resultData = schema ? schemaModel(baseData, schema, true) : baseData;
+        return formatApiResponse(resultData, response.status, Object.fromEntries(response.headers));
+      } catch (err) {
+        logger.error(err);
+        logger.error(`Response Zod validation error for ${url}`);
+        return formatApiError(`Invalid response data from endpoint: ${url}`, 500);
+      }
+    }).catch((err) => {
+      if (err instanceof Error && err.name === "AbortError") {
+        return formatApiError("Request aborted", 499, err, "request-aborted");
+      }
+      if (err instanceof Error && isDeadlineError(err)) {
+        if (config2.signal?.aborted) {
+          return formatApiError("Request aborted", 499, err, "request-aborted");
+        }
+        logger.error(err);
+        logger.error(`Request to ${url} timed out`);
+        return formatApiError("Request timed out", 504, err, "request-timeout");
+      }
+      logger.error(err);
+      return formatApiError("Unknown Error", 500);
+    });
+  }
+  return {
+    baseUrl,
+    getAuthToken,
+    request
+  };
+}
+
+// ../../packages/service-api/dist/apis/auth.js
+function authApiFactory(requestService) {
+  async function requestPasswordReset(email) {
+    return await requestService.request({
+      url: "core/login/request-password-reset",
+      method: "post",
+      data: {
+        email,
+        clientId: nanoid()
+      },
+      schema: external_exports.null(),
+      disableAuth: true
+    });
+  }
+  async function resetPassword(password, clientId, resetToken) {
+    return await requestService.request({
+      url: "core/login/reset-password",
+      method: "post",
+      data: {
+        clientId,
+        resetToken,
+        password
+      },
+      disableAuth: true,
+      schema: external_exports.object({
+        accessToken: external_exports.string(),
+        refreshToken: external_exports.string()
+      })
+    });
+  }
+  async function generatePersonalToken({ name, description, refreshToken: refreshToken2 }) {
+    return await requestService.request({
+      url: "core/login/personal-token/generate",
+      method: "post",
+      data: {
+        name,
+        description,
+        refreshToken: refreshToken2
+      },
+      schema: external_exports.object({
+        uid: external_exports.string(),
+        personalToken: external_exports.string()
+      })
+    });
+  }
+  async function getAccessTokenByPersonalToken({ personalToken }) {
+    return await requestService.request({
+      url: "core/login/personal-token/access",
+      method: "post",
+      data: {
+        personalToken
+      },
+      schema: external_exports.object({
+        accessToken: external_exports.string()
+      })
+    });
+  }
+  async function revokePersonalToken({ uid }) {
+    return await requestService.request({
+      url: `core/login/personal-token/${uid}/revoke`,
+      method: "post",
+      schema: external_exports.null()
+    });
+  }
+  async function deletePersonalToken({ uid }) {
+    return await requestService.request({
+      url: `core/login/personal-token/${uid}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function getIdentityProvider(uid) {
+    return await requestService.request({
+      url: `core/identity-provider/${uid}`,
+      method: "get",
+      schema: identityProviderRecordSchema
+    });
+  }
+  async function createIdentityProvider(data) {
+    return await requestService.request({
+      url: "core/identity-provider",
+      method: "post",
+      data,
+      schema: identityProviderRecordSchema
+    });
+  }
+  async function updateIdentityProvider(uid, data) {
+    return await requestService.request({
+      url: "core/identity-provider/update",
+      method: "post",
+      data: {
+        uid,
+        ...data
+      },
+      schema: identityProviderRecordSchema
+    });
+  }
+  async function deleteIdentityProvider(uid) {
+    return await requestService.request({
+      url: `core/identity-provider/${uid}`,
+      method: "delete",
+      schema: external_exports.null()
+    });
+  }
+  async function initiateSaml(data) {
+    return await requestService.request({
+      url: "core/saml/initiate",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        options: external_exports.object({
+          loginUrl: external_exports.url(),
+          provider: external_exports.enum(identityProviders),
+          teamSlug: slugSchema
+        }).array()
+      })
+    });
+  }
+  async function changePassword({ oldPassword, newPassword }) {
+    return await requestService.request({
+      url: "core/login/change-password",
+      method: "post",
+      data: {
+        oldPassword,
+        newPassword
+      },
+      schema: external_exports.null()
+    });
+  }
+  return {
+    requestPasswordReset,
+    resetPassword,
+    changePassword,
+    // Personal tokens
+    generatePersonalToken,
+    getAccessTokenByPersonalToken,
+    revokePersonalToken,
+    deletePersonalToken,
+    // Identity Provider,
+    getIdentityProvider,
+    createIdentityProvider,
+    updateIdentityProvider,
+    deleteIdentityProvider,
+    // SAML
+    initiateSaml
+  };
+}
+
+// ../../packages/service-api/dist/apis/bitbucket.js
+var bitbucketRepoSummarySchema = external_exports.object({
+  uuid: external_exports.string(),
+  slug: external_exports.string(),
+  fullName: external_exports.string(),
+  defaultBranch: external_exports.string(),
+  isPrivate: external_exports.boolean(),
+  workspaceUuid: external_exports.string(),
+  workspaceSlug: external_exports.string()
+});
+var bitbucketWorkspaceSchema = external_exports.object({
+  uuid: external_exports.string(),
+  slug: external_exports.string(),
+  name: external_exports.string(),
+  iconUrl: external_exports.string().optional(),
+  repos: bitbucketRepoSummarySchema.array()
+});
+function bitbucketApiFactory(requestService) {
+  async function initiateLink(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.redirect)
+      params.set("redirect", opts.redirect);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return await requestService.request({
+      url: `core/vcs/bitbucket/link/initiate${qs}`,
+      method: "get",
+      schema: external_exports.object({ url: external_exports.string() })
+    });
+  }
+  async function getWorkspaces() {
+    return await requestService.request({
+      url: "core/vcs/bitbucket/workspaces",
+      method: "get",
+      schema: bitbucketWorkspaceSchema.array()
+    });
+  }
+  async function listDocsProjectBitbucketBranches(uid, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.query)
+      params.set("query", opts.query);
+    if (opts.page !== void 0)
+      params.set("page", String(opts.page));
+    if (opts.perPage !== void 0)
+      params.set("perPage", String(opts.perPage));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return await requestService.request({
+      url: `core/vcs/bitbucket/docs-project/${uid}/branches${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        branches: external_exports.object({
+          name: external_exports.string(),
+          isDefault: external_exports.boolean()
+        }).array(),
+        hasMore: external_exports.boolean()
+      })
+    });
+  }
+  async function disconnectAccount() {
+    return await requestService.request({
+      url: "core/vcs/bitbucket/disconnect-account",
+      method: "post",
+      schema: external_exports.object({ success: external_exports.literal(true) })
+    });
+  }
+  return {
+    initiateLink,
+    getWorkspaces,
+    listDocsProjectBitbucketBranches,
+    disconnectAccount
+  };
+}
+
+// ../../packages/service-api/dist/apis/docs-project.js
+function docsProjectApiFactory(requestService) {
+  async function listProjects(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    const suffix = query.size ? `?${query.toString()}` : "";
+    return await requestService.request({
+      url: `core/docs-projects${suffix}`,
+      method: "get",
+      schema: external_exports.object({
+        data: docsProjectSchema.array(),
+        hasMore: external_exports.boolean()
+      })
+    });
+  }
+  async function createProject(data) {
+    return await requestService.request({
+      url: "core/docs-projects/create",
+      method: "post",
+      data,
+      schema: docsProjectSchema
+    });
+  }
+  async function deleteProject(projectUid) {
+    return await requestService.request({
+      url: "core/docs-projects/delete",
+      method: "delete",
+      data: { projectUid },
+      schema: external_exports.null()
+    });
+  }
+  async function getProject(slug) {
+    return await requestService.request({
+      url: `core/docs-projects/${slug}`,
+      method: "get",
+      schema: docsProjectSchema
+    });
+  }
+  async function getConfig(projectUid, opts) {
+    const qs = opts?.ref ? `?ref=${encodeURIComponent(opts.ref)}` : "";
+    return await requestService.request({
+      url: `core/docs-projects/${projectUid}/config${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        path: external_exports.string(),
+        content: external_exports.string(),
+        ref: external_exports.string(),
+        /** Compare-and-swap handle for a later write; empty when unsupported. */
+        baseToken: external_exports.string()
+      })
+    });
+  }
+  async function putConfig(projectUid, data) {
+    return await requestService.request({
+      url: `core/docs-projects/${projectUid}/config`,
+      method: "put",
+      data,
+      schema: external_exports.object({
+        commitSha: external_exports.string().nullable(),
+        ref: external_exports.string(),
+        /** Base for the next write; empty when the provider offers none. */
+        baseToken: external_exports.string()
+      })
+    });
+  }
+  async function getGitCredentials() {
+    return await requestService.request({
+      url: "core/forgejo/git-credentials",
+      method: "get",
+      schema: external_exports.object({
+        forgejoBaseUrl: external_exports.string(),
+        forgejoToken: external_exports.string(),
+        forgejoUsername: external_exports.string()
+      })
+    });
+  }
+  async function updateRepoSettings(projectUid, patch) {
+    return await requestService.request({
+      url: "core/docs-projects/update-repo-settings",
+      method: "post",
+      data: { projectUid, ...patch },
+      schema: external_exports.null()
+    });
+  }
+  async function linkGithub(data) {
+    return await requestService.request({
+      url: `core/docs-projects/${data.projectUid}/link-github`,
+      method: "post",
+      data: { installationId: data.installationId, repoId: data.repoId },
+      schema: external_exports.object({
+        /** Null when the repo had no commits and the docs went straight onto it. */
+        pullRequest: external_exports.object({
+          url: external_exports.string(),
+          number: external_exports.number().int(),
+          branch: external_exports.string()
+        }).nullable(),
+        project: docsProjectSchema
+      })
+    });
+  }
+  async function unlinkGithub(projectUid) {
+    return await requestService.request({
+      url: `core/docs-projects/${projectUid}/unlink-github`,
+      method: "post",
+      schema: external_exports.object({ project: docsProjectSchema })
+    });
+  }
+  async function linkBitbucket(data) {
+    return await requestService.request({
+      url: `core/docs-projects/${data.projectUid}/link-bitbucket`,
+      method: "post",
+      data: {
+        workspaceUuid: data.workspaceUuid,
+        repoUuid: data.repoUuid
+      },
+      schema: external_exports.object({
+        pullRequest: external_exports.object({
+          url: external_exports.string(),
+          number: external_exports.number().int(),
+          branch: external_exports.string()
+        }),
+        project: docsProjectSchema
+      })
+    });
+  }
+  async function unlinkBitbucket(projectUid) {
+    return await requestService.request({
+      url: `core/docs-projects/${projectUid}/unlink-bitbucket`,
+      method: "post",
+      schema: external_exports.object({ project: docsProjectSchema })
+    });
+  }
+  async function switchRepository(data) {
+    return await requestService.request({
+      url: `core/docs-projects/${data.projectUid}/switch-repository`,
+      method: "post",
+      data: { target: data.target },
+      schema: external_exports.object({ project: docsProjectSchema })
+    });
+  }
+  async function refreshBitbucketWebhook(projectUid) {
+    return await requestService.request({
+      url: `core/docs-projects/${projectUid}/bitbucket/refresh-webhook`,
+      method: "post",
+      schema: external_exports.object({ project: docsProjectSchema })
+    });
+  }
+  return {
+    listProjects,
+    createProject,
+    deleteProject,
+    getProject,
+    getConfig,
+    putConfig,
+    getGitCredentials,
+    updateRepoSettings,
+    linkGithub,
+    unlinkGithub,
+    linkBitbucket,
+    unlinkBitbucket,
+    refreshBitbucketWebhook,
+    switchRepository
+  };
+}
+
+// ../../packages/service-api/dist/apis/feedback.js
+function feedbackApiFactory(requestService) {
+  async function submit(email, feedback) {
+    return await requestService.request({
+      url: "core/feedback",
+      method: "post",
+      data: {
+        email,
+        feedback
+      },
+      schema: external_exports.null()
+    });
+  }
+  return {
+    submit
+  };
+}
+
+// ../../packages/service-api/dist/apis/github.js
+function githubApiFactory(requestService) {
+  async function initiateLink(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.redirect)
+      params.set("redirect", opts.redirect);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return await requestService.request({
+      url: `core/github/link/initiate${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        url: external_exports.string()
+      })
+    });
+  }
+  async function getRepos() {
+    return await requestService.request({
+      url: "core/github/repos",
+      method: "get",
+      schema: githubInstallSchema.array()
+    });
+  }
+  async function getInstalls() {
+    return await requestService.request({
+      url: "core/github/installs",
+      method: "get",
+      schema: external_exports.object({
+        id: external_exports.number(),
+        name: external_exports.string(),
+        icon: external_exports.string().optional()
+      }).array()
+    });
+  }
+  async function getInstallRepos(installationId, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.page !== void 0)
+      params.set("page", String(opts.page));
+    if (opts.perPage !== void 0)
+      params.set("perPage", String(opts.perPage));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return await requestService.request({
+      url: `core/github/installs/${installationId}/repos${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        repos: external_exports.object({ id: external_exports.number(), name: external_exports.string() }).array(),
+        hasMore: external_exports.boolean(),
+        totalCount: external_exports.number()
+      })
+    });
+  }
+  async function getRepoInfo(id) {
+    return await requestService.request({
+      url: `core/github/repos/${id}`,
+      method: "get",
+      schema: external_exports.object({
+        name: external_exports.string(),
+        description: external_exports.string().optional(),
+        private: external_exports.boolean(),
+        url: external_exports.string(),
+        src: external_exports.string().optional()
+      })
+    });
+  }
+  async function linkRepo(data) {
+    return await requestService.request({
+      url: "core/github/link-repo",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function unlinkRepo(data) {
+    return await requestService.request({
+      url: "core/github/unlink-repo",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function getDocsProjectGithubCommits(uid, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.branch)
+      params.set("branch", opts.branch);
+    if (opts.page !== void 0)
+      params.set("page", String(opts.page));
+    if (opts.perPage !== void 0)
+      params.set("perPage", String(opts.perPage));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return await requestService.request({
+      url: `core/github/docs-project/${uid}/commits${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        sha: external_exports.string(),
+        message: external_exports.string(),
+        authorName: external_exports.string(),
+        authorEmail: external_exports.string(),
+        timestamp: external_exports.number()
+      }).array()
+    });
+  }
+  async function listDocsProjectGithubBranches(uid, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.query)
+      params.set("query", opts.query);
+    if (opts.page !== void 0)
+      params.set("page", String(opts.page));
+    if (opts.perPage !== void 0)
+      params.set("perPage", String(opts.perPage));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return await requestService.request({
+      url: `core/github/docs-project/${uid}/branches${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        branches: external_exports.object({
+          name: external_exports.string(),
+          isDefault: external_exports.boolean()
+        }).array(),
+        hasMore: external_exports.boolean()
+      })
+    });
+  }
+  async function createDocsProjectGithubPullRequest(uid, data) {
+    return await requestService.request({
+      url: `core/github/docs-project/${uid}/pull-request`,
+      method: "post",
+      data,
+      schema: external_exports.object({
+        url: external_exports.string(),
+        number: external_exports.number(),
+        alreadyExists: external_exports.boolean()
+      })
+    });
+  }
+  async function getDocsProjectGithubPullRequestForBranch(uid, branch) {
+    const qs = new URLSearchParams({ branch }).toString();
+    return await requestService.request({
+      url: `core/github/docs-project/${uid}/pull-request/for-branch?${qs}`,
+      method: "get",
+      schema: external_exports.object({
+        pullRequest: external_exports.object({
+          url: external_exports.string(),
+          number: external_exports.number(),
+          title: external_exports.string(),
+          body: external_exports.string()
+        }).nullable()
+      })
+    });
+  }
+  async function publishRepo(githubProjectId) {
+    return await requestService.request({
+      url: "core/publish/github",
+      method: "post",
+      data: { projectId: githubProjectId },
+      schema: external_exports.object({
+        publishUid: external_exports.string()
+      })
+    });
+  }
+  async function checkSlug(slug) {
+    return await requestService.request({
+      url: "core/github/slug/available",
+      method: "post",
+      data: { slug },
+      schema: external_exports.object({
+        isAvailable: external_exports.boolean()
+      })
+    });
+  }
+  async function updateSlug(uid, slug) {
+    return await requestService.request({
+      url: "core/github/slug",
+      method: "post",
+      data: { uid, slug },
+      schema: external_exports.null()
+    });
+  }
+  async function getProject(slug) {
+    return await requestService.request({
+      url: `core/github/${slug}`,
+      method: "get",
+      schema: githubProjectSchema
+    });
+  }
+  async function getProjects() {
+    return await requestService.request({
+      url: "core/github/list-projects",
+      method: "get",
+      schema: githubProjectSchema.array()
+    });
+  }
+  async function deleteProject(projectUid) {
+    return await requestService.request({
+      url: "core/github/delete",
+      method: "post",
+      data: { projectUid },
+      schema: external_exports.null()
+    });
+  }
+  async function createProject({ name, slug, isPrivate, accessGroups, allowedUsers, allowedDomains, repositoryId }) {
+    return await requestService.request({
+      url: "core/github/create",
+      method: "post",
+      data: {
+        name,
+        slug,
+        isPrivate,
+        accessGroups,
+        allowedUsers,
+        allowedDomains,
+        repositoryId
+      },
+      schema: external_exports.object({
+        uid: external_exports.string(),
+        slug: external_exports.string()
+      })
+    });
+  }
+  async function disconnectAccount() {
+    return await requestService.request({
+      url: "core/vcs/github/disconnect-account",
+      method: "post",
+      schema: external_exports.object({ success: external_exports.literal(true) })
+    });
+  }
+  async function validateConfigFile(uid, configPath) {
+    return await requestService.request({
+      url: "core/github/config/validate",
+      method: "post",
+      data: { projectId: uid, configPath },
+      schema: external_exports.union([
+        external_exports.object({
+          config: external_exports.string(),
+          success: external_exports.literal(true),
+          version: external_exports.string().optional(),
+          path: external_exports.string().optional()
+        }),
+        external_exports.object({
+          config: external_exports.string(),
+          success: external_exports.literal(false),
+          version: external_exports.string().optional(),
+          error: external_exports.string().array(),
+          path: external_exports.string().optional()
+        })
+      ])
+    });
+  }
+  return {
+    initiateLink,
+    getRepos,
+    getInstalls,
+    getInstallRepos,
+    linkRepo,
+    unlinkRepo,
+    getDocsProjectGithubCommits,
+    listDocsProjectGithubBranches,
+    createDocsProjectGithubPullRequest,
+    getDocsProjectGithubPullRequestForBranch,
+    publishRepo,
+    getRepoInfo,
+    checkSlug,
+    updateSlug,
+    createProject,
+    deleteProject,
+    validateConfigFile,
+    getProject,
+    getProjects,
+    disconnectAccount
+  };
+}
+
+// ../../packages/service-api/dist/apis/hocuspocus.js
+function hocuspocusApiFactory(requestService) {
+  async function fetchDoc(name) {
+    return await requestService.request({
+      url: `hocuspocus/doc/${name}`,
+      method: "get",
+      schema: external_exports.any()
+    });
+  }
+  async function fetchReference(name) {
+    return await requestService.request({
+      url: `hocuspocus/doc/${name}`,
+      method: "get",
+      schema: external_exports.any()
+    });
+  }
+  async function fetchReferences(yjsRefs) {
+    return await requestService.request({
+      url: "hocuspocus/doc/batch",
+      method: "post",
+      data: {
+        items: yjsRefs.map((ref) => `reference-${ref}`),
+        parser: "reference"
+      },
+      schema: external_exports.record(external_exports.string(), external_exports.string().nullable())
+    });
+  }
+  return {
+    fetchDoc,
+    fetchReference,
+    fetchReferences
+  };
+}
+
+// ../../packages/service-api/dist/apis/image.js
+function imageApiFactory(requestService) {
+  async function upload(file) {
+    const formData = new FormData();
+    formData.append("image", file);
+    return await requestService.request({
+      url: "image-uploader/",
+      method: "post",
+      data: formData,
+      schema: external_exports.object({ imageUrl: external_exports.string() })
+    });
+  }
+  async function remove(imageUrl) {
+    return await requestService.request({
+      url: "image-uploader/",
+      method: "delete",
+      data: { imageUrl },
+      schema: external_exports.null()
+    });
+  }
+  return {
+    upload,
+    remove
+  };
+}
+
+// ../../packages/service-api/dist/apis/payment.js
+function paymentApiFactory(requestService) {
+  async function startSession(billingPlan, redirectUrl, flow) {
+    return await requestService.request({
+      url: "core/payment/start",
+      method: "post",
+      data: {
+        billingPlan,
+        redirectUrl,
+        flow
+      },
+      schema: external_exports.string()
+    });
+  }
+  async function startBillingSession(data) {
+    return await requestService.request({
+      url: "core/payment/billing/start",
+      method: "post",
+      schema: external_exports.string(),
+      data
+    });
+  }
+  return {
+    startSession,
+    startBillingSession
+  };
+}
+
+// ../../packages/service-api/dist/apis/project.js
+function projectApiFactory(requestService) {
+  async function createProject(name, hideGuide, hideReference) {
+    return await requestService.request({
+      url: "core/docs/create-project",
+      method: "post",
+      data: {
+        name,
+        hideGuide,
+        hideReference
+      },
+      schema: projectSchema
+    });
+  }
+  async function updateProject(projectUid, data) {
+    return await requestService.request({
+      url: "core/project/update",
+      method: "post",
+      data: { projectUid, ...data },
+      schema: external_exports.null()
+    });
+  }
+  async function deleteProject(projectId) {
+    return await requestService.request({
+      url: "core/docs/delete-project",
+      method: "delete",
+      data: { projectId },
+      schema: external_exports.null()
+    });
+  }
+  async function changeProjectPrivacy(projectUid, makePrivate) {
+    return await requestService.request({
+      url: "core/docs/project/change-privacy",
+      method: "post",
+      data: { projectUid, makePrivate },
+      schema: external_exports.null()
+    });
+  }
+  async function createVersion(data) {
+    return await requestService.request({
+      url: "core/docs/version",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        uid: nanoidSchema
+      })
+    });
+  }
+  return {
+    createProject,
+    deleteProject,
+    changeProjectPrivacy,
+    createVersion,
+    updateProject
+  };
+}
+
+// ../../packages/service-api/dist/apis/publish.js
+function publishApiFactory(requestService) {
+  async function publishCli({ tarStream, configPath, slug, mode }) {
+    const params = new URLSearchParams({
+      slug,
+      configPath,
+      ...mode && { mode }
+    });
+    return await requestService.request({
+      url: `publish-deploy/publish/cli?${params.toString()}`,
+      method: "post",
+      data: tarStream,
+      headers: {
+        "Content-Type": "application/octet-stream"
+      },
+      schema: external_exports.object({ publishUid: nanoidSchema })
+    });
+  }
+  async function publishGithub({ slug, configPath, preview, commitSha }) {
+    return await requestService.request({
+      url: "publish-deploy/publish/github",
+      method: "post",
+      data: {
+        slug,
+        configPath,
+        preview,
+        commitSha
+      },
+      schema: external_exports.object({ publishUid: nanoidSchema })
+    });
+  }
+  async function publishDocsProject({ slug, configPath, preview, pullRequestComments, commitSha }) {
+    return await requestService.request({
+      url: "publish-deploy/publish/docs-project",
+      method: "post",
+      data: {
+        slug,
+        configPath,
+        preview,
+        pullRequestComments,
+        commitSha
+      },
+      schema: external_exports.object({ publishUid: nanoidSchema })
+    });
+  }
+  async function publishWysiwyg(uid) {
+    return await requestService.request({
+      url: "publish-deploy/publish/wysiwyg",
+      method: "post",
+      data: {
+        uid
+      },
+      schema: external_exports.object({
+        publishUid: nanoidSchema
+      })
+    });
+  }
+  async function publishTemplate({ slug, repository, branch, configPath }) {
+    return await requestService.request({
+      url: "publish-deploy/publish/template",
+      method: "post",
+      data: {
+        slug,
+        repository,
+        branch,
+        configPath
+      },
+      schema: external_exports.object({ publishUid: nanoidSchema })
+    });
+  }
+  async function createPreviewSandbox(repo) {
+    return await requestService.request({
+      url: "publish-deploy/preview-sandbox",
+      method: "post",
+      data: repo,
+      schema: external_exports.object({
+        sandboxId: external_exports.string(),
+        gitUrl: external_exports.string(),
+        previewUrl: external_exports.string()
+      })
+    });
+  }
+  async function stopPreviewSandbox({ sandboxId, keepalive }) {
+    return await requestService.request({
+      url: "publish-deploy/preview-sandbox/stop",
+      method: "post",
+      data: { sandboxId },
+      schema: external_exports.null(),
+      ...keepalive && { keepalive: true }
+    });
+  }
+  async function getPreviewSandboxLog({ sandboxId }) {
+    return await requestService.request({
+      url: "publish-deploy/preview-sandbox/log",
+      method: "post",
+      data: { sandboxId },
+      schema: external_exports.object({
+        log: external_exports.string().nullable()
+      })
+    });
+  }
+  async function checkDNSRecords(domain) {
+    return await requestService.request({
+      url: "core/publish/dns-check",
+      method: "post",
+      data: {
+        domain
+      },
+      schema: external_exports.object({
+        status: external_exports.enum(["verified", "pending", "misconfigured"]),
+        expected: external_exports.object({
+          type: external_exports.literal("CNAME"),
+          target: external_exports.string()
+        }),
+        found: external_exports.array(external_exports.string())
+      })
+    });
+  }
+  async function unpublish(projectUid, githubProjectUid, unifiedProjectUid) {
+    return await requestService.request({
+      url: "core/unpublish",
+      method: "delete",
+      data: {
+        projectUid,
+        githubProjectUid,
+        unifiedProjectUid
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function redeploy(publishUid) {
+    return await requestService.request({
+      url: "core/publish/redeploy",
+      method: "post",
+      data: {
+        publishUid
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function cancelPublish(publishUid) {
+    return await requestService.request({
+      url: "core/publish/cancel",
+      method: "post",
+      data: {
+        publishUid
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function deleteRecord(publishUid) {
+    return await requestService.request({
+      url: "core/publish",
+      method: "delete",
+      data: {
+        publishUid
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function bulkDelete(projectUid) {
+    return await requestService.request({
+      url: "core/publish/bulk",
+      method: "delete",
+      data: {
+        projectUid
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function getPublishLogs(publishUid) {
+    return await requestService.request({
+      url: `core/publish/logs/${publishUid}`,
+      method: "get",
+      schema: external_exports.string(),
+      stream: true
+    });
+  }
+  async function getDomainAvailability(domain) {
+    return await requestService.request({
+      url: "core/publish/domains/availability",
+      method: "post",
+      data: {
+        domain
+      },
+      schema: external_exports.object({
+        available: external_exports.boolean()
+      })
+    });
+  }
+  async function getProjectDomains(projectUid) {
+    return await requestService.request({
+      url: "core/publish/domains/project",
+      method: "post",
+      data: {
+        projectUid
+      },
+      schema: external_exports.object({
+        scalarDomain: external_exports.string().nullable(),
+        customDomain: external_exports.string().nullable()
+      })
+    });
+  }
+  async function exportWysiwyg(uid, filename) {
+    const token = requestService.getAuthToken?.();
+    const url = `${requestService.baseUrl}/publish-deploy/export/wysiwyg`.replace(/([^:]\/)\/+/g, "$1");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify({ uid })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "Export failed");
+      return { error: true, message: text, status: response.status };
+    }
+    const blob = await response.blob();
+    const downloadUrl = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = downloadUrl;
+    a.download = filename ?? "project-export.zip";
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(downloadUrl);
+    return { error: false };
+  }
+  return {
+    publishCli,
+    publishDocsProject,
+    publishGithub,
+    publishTemplate,
+    publishWysiwyg,
+    createPreviewSandbox,
+    stopPreviewSandbox,
+    getPreviewSandboxLog,
+    exportWysiwyg,
+    checkDNSRecords,
+    unpublish,
+    deleteRecord,
+    redeploy,
+    cancelPublish,
+    bulkDelete,
+    getPublishLogs,
+    getDomainAvailability,
+    getProjectDomains
+  };
+}
+
+// ../../packages/service-api/dist/apis/signup.js
+function signupApiFactory(requestService) {
+  async function saveData(signupData) {
+    return await requestService.request({
+      url: "core/signup-data",
+      method: "post",
+      data: signupData,
+      schema: external_exports.object({ dataUid: external_exports.string() })
+    });
+  }
+  return {
+    saveData
+  };
+}
+
+// ../../packages/service-api/dist/apis/team.js
+function teamApiFactory(requestService, getNewTokens) {
+  async function list() {
+    return await requestService.request({
+      url: "core/me/teams",
+      method: "get",
+      schema: external_exports.object({
+        uid: nanoidSchema,
+        name: teamNameSchema,
+        slug: slugSchema,
+        imageUri: teamImageSchema,
+        theme: external_exports.string()
+      }).array()
+    });
+  }
+  async function create(data) {
+    return await requestService.request({
+      url: "core/team/create",
+      method: "post",
+      data,
+      schema: external_exports.object({
+        teamUid: external_exports.string()
+      })
+    }).then(async (r) => {
+      if (!r.error)
+        await getNewTokens(r.data.teamUid);
+      return r;
+    });
+  }
+  async function getMembers() {
+    return await requestService.request({
+      url: "core/team/members",
+      method: "get",
+      schema: external_exports.object({
+        members: userRefSchema.array(),
+        pendingInvites: pendingInviteSchema.array()
+      })
+    });
+  }
+  async function inviteMember(data) {
+    return await requestService.request({
+      url: "core/team/invite",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeInvite(invitedUserUid) {
+    return await requestService.request({
+      url: "core/team/invite",
+      method: "delete",
+      data: { uid: invitedUserUid },
+      schema: external_exports.null()
+    });
+  }
+  async function resendInvite(inviteUid) {
+    return await requestService.request({
+      url: "core/team/invite",
+      method: "patch",
+      data: { uid: inviteUid },
+      schema: external_exports.null()
+    });
+  }
+  async function updateSlug(slug) {
+    return await requestService.request({
+      url: "core/team/slug",
+      method: "post",
+      data: { slug },
+      schema: external_exports.null()
+    });
+  }
+  async function checkSlug(slug) {
+    return await requestService.request({
+      url: "core/team/slug/available",
+      method: "post",
+      data: { slug },
+      schema: external_exports.object({
+        isAvailable: external_exports.boolean()
+      })
+    });
+  }
+  async function createNamespace(namespace) {
+    return await requestService.request({
+      url: "core/team/namespace",
+      method: "post",
+      data: { namespace },
+      schema: external_exports.null()
+    });
+  }
+  async function getNamespaces() {
+    return await requestService.request({
+      url: "core/team/namespaces",
+      method: "get",
+      schema: external_exports.string().array()
+    });
+  }
+  async function updateNamespace(namespace, newNamespace) {
+    return await requestService.request({
+      url: "core/team/namespace/update",
+      method: "post",
+      data: { namespace, newNamespace },
+      schema: external_exports.null()
+    });
+  }
+  async function checkNamespace(namespace) {
+    return await requestService.request({
+      url: "core/team/namespace/available",
+      method: "post",
+      data: { namespace },
+      schema: external_exports.object({
+        isAvailable: external_exports.boolean()
+      })
+    });
+  }
+  async function rename(name) {
+    return await requestService.request({
+      url: "core/team/rename",
+      method: "post",
+      data: { name },
+      schema: external_exports.null()
+    });
+  }
+  async function requestUnifiedDocsMigration() {
+    return await requestService.request({
+      url: "core/team/request-unified-docs-migration",
+      method: "post",
+      data: {},
+      schema: external_exports.object({
+        status: external_exports.enum(UnifiedDocsMigrationStatus)
+      })
+    });
+  }
+  async function leave() {
+    return await requestService.request({
+      url: "core/team/leave",
+      method: "get",
+      schema: external_exports.null()
+    }).then(async (r) => {
+      if (!r.error)
+        await getNewTokens();
+      return r;
+    });
+  }
+  async function removeMember(userUid) {
+    return await requestService.request({
+      url: "core/team/delete-member",
+      method: "post",
+      data: {
+        userUid
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function updateRole(data) {
+    return await requestService.request({
+      url: "core/team/update-role",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function deleteTeam() {
+    return await requestService.request({
+      url: "core/team",
+      method: "delete",
+      data: null,
+      schema: external_exports.object({
+        newTeamUid: nanoidSchema.nullable()
+      })
+    }).then(async (r) => {
+      if (!r.error)
+        await getNewTokens();
+      return r;
+    });
+  }
+  async function updateImage(imageUri) {
+    return await requestService.request({
+      url: "core/team/image",
+      method: "post",
+      data: {
+        imageUri
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function update(data) {
+    return await requestService.request({
+      url: "core/team/update",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function updateTeamUser(updateRequestData) {
+    return await requestService.request({
+      url: "core/team/update-user",
+      method: "post",
+      data: updateRequestData,
+      schema: external_exports.null()
+    });
+  }
+  async function getBillingSummary() {
+    return await requestService.request({
+      url: "core/team/billing",
+      method: "get",
+      schema: teamBillingSummary
+    });
+  }
+  async function getSdkPricing() {
+    return await requestService.request({
+      url: "core/team/sdk-pricing",
+      method: "get",
+      schema: teamSdkPricing
+    });
+  }
+  async function updateBillingPlan(billingPlan) {
+    return await requestService.request({
+      url: "core/team/update/plan",
+      method: "post",
+      data: {
+        billingPlan
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function updateBillingEmail(email) {
+    return await requestService.request({
+      url: "core/team/billing/email",
+      method: "post",
+      data: {
+        email
+      },
+      schema: external_exports.null()
+    });
+  }
+  async function extendTrial() {
+    return await requestService.request({
+      url: "core/team/extend-trial",
+      method: "post",
+      data: {},
+      schema: external_exports.null()
+    });
+  }
+  async function onboardingSetup(data) {
+    return await requestService.request({
+      url: "core/team/onboarding/complete",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function onboardingComplete() {
+    return await requestService.request({
+      url: "core/team/onboarding/complete",
+      method: "post",
+      data: {},
+      schema: external_exports.null()
+    });
+  }
+  async function addTeamIcon(data) {
+    return await requestService.request({
+      url: "core/team/icon",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeTeamIcon(data) {
+    return await requestService.request({
+      url: "core/team/icon",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function addAuthenticationDomain(data) {
+    return await requestService.request({
+      url: "core/team/authentication/domain",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function deleteAuthenticationDomain(data) {
+    return await requestService.request({
+      url: "core/team/authentication/domain",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function toggleAuthenticationMethod(data) {
+    return await requestService.request({
+      url: "core/team/authentication/method",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function editAuthenticationUserControls(data) {
+    return await requestService.request({
+      url: "core/team/authentication/user",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function removeAuthenticationUserControls(data) {
+    return await requestService.request({
+      url: "core/team/authentication/user",
+      method: "delete",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function toggleUserAuthenticationMethod(data) {
+    return await requestService.request({
+      url: "core/team/authentication/user/method",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  async function toggleExternalAccessMethod(data) {
+    return await requestService.request({
+      url: "core/team/external-access/method",
+      method: "post",
+      data,
+      schema: external_exports.null()
+    });
+  }
+  return {
+    list,
+    create,
+    getMembers,
+    inviteMember,
+    removeInvite,
+    resendInvite,
+    rename,
+    requestUnifiedDocsMigration,
+    leave,
+    removeMember,
+    delete: deleteTeam,
+    getBillingSummary,
+    getSdkPricing,
+    updateBillingEmail,
+    updateBillingPlan,
+    extendTrial,
+    update,
+    updateRole,
+    updateTeamUser,
+    updateImage,
+    updateSlug,
+    checkSlug,
+    getNamespaces,
+    createNamespace,
+    updateNamespace,
+    checkNamespace,
+    onboardingSetup,
+    onboardingComplete,
+    addTeamIcon,
+    removeTeamIcon,
+    addAuthenticationDomain,
+    deleteAuthenticationDomain,
+    toggleAuthenticationMethod,
+    editAuthenticationUserControls,
+    removeAuthenticationUserControls,
+    toggleUserAuthenticationMethod,
+    toggleExternalAccessMethod
+  };
+}
+
+// ../../packages/service-api/dist/index.js
+var apiServiceFactory = (baseUrl, getAuthToken, getNewTokens) => {
+  const requestService = requestServiceFactory(baseUrl, getAuthToken);
+  return {
+    user: userApiFactory(requestService),
+    auth: authApiFactory(requestService),
+    team: teamApiFactory(requestService, getNewTokens),
+    feedback: feedbackApiFactory(requestService),
+    image: imageApiFactory(requestService),
+    payment: paymentApiFactory(requestService),
+    hocuspocus: hocuspocusApiFactory(requestService),
+    publish: publishApiFactory(requestService),
+    github: githubApiFactory(requestService),
+    bitbucket: bitbucketApiFactory(requestService),
+    signup: signupApiFactory(requestService),
+    project: projectApiFactory(requestService),
+    docsProject: docsProjectApiFactory(requestService),
+    managedDocs: managedDocsApiFactory(requestService),
+    managedSchemas: managedSchemasApiFactory(requestService),
+    rules: rulesApiFactory(requestService),
+    registryGit: registryGitApiFactory(requestService),
+    registryInstances: registryInstancesApiFactory(requestService),
+    themes: themesApiFactory(requestService),
+    accessGroups: accessGroupsApiFactory(requestService),
+    webhooks: webhooksApiFactory(requestService),
+    loginPortals: loginPortalsApiFactory(requestService),
+    sdks: sdksApiFactory(requestService),
+    waitlist: waitlistApiFactory(requestService),
+    workspace: workspaceApiFactory(requestService),
+    analytics: analyticsApiFactory(requestService)
+  };
+};
+
+// src/helpers/api-service.ts
+var apiService = async (opts) => {
+  const auth = await getAuthData(opts);
+  auth.addEventListener((state) => Object.assign(auth, state));
+  return apiServiceFactory(
+    config.services.api,
+    () => auth.accessToken,
+    async (teamUid) => {
+      if ("refreshToken" in auth) {
+        await refreshToken(auth.refreshToken, teamUid);
+        return;
+      }
+      await generateAccessByPersonalToken({
+        personalToken: auth.personalToken
+      });
+    }
+  );
+};
+
+export {
+  apiService
+};