@scalar/cli 2.1.0 → 2.5.1

package/chunks/{chunk-SXYALPYK.js → chunk-AO3F5XWR.js}

@@ -5,50 +5,64 @@ import {
   accessGroupSchema,
   identityProviderRecordSchema,
   identityProviders,
+  linkedRepositorySchema,
   loginPortalSchema,
   managedSchema,
+  managedSchemaVersion,
+  webhookDeliverySchema,
+  webhookSubscriptionSchema,
   workspaceSchema,
   workspaceVersionSchema
-} from "./chunk-UPUTMFD4.js";
+} from "./chunk-HCPN3KNF.js";
 import {
   userSchema
-} from "./chunk-B6QZJWCQ.js";
+} from "./chunk-B2MHTD3R.js";
 import {
-  managedDocSchema,
-  managedDocVersionSchema,
-  ruleSchema
-} from "./chunk-4QS7SJTG.js";
-import {
-  registryGitBindingSchema,
-  registryPublishRecordSchema
-} from "./chunk-VTYTPSXO.js";
+  sdkSchema
+} from "./chunk-3L6DLIXJ.js";
 import {
   generateAccessByPersonalToken,
   getAuthData,
   refreshToken
-} from "./chunk-5BISXQX4.js";
+} from "./chunk-M37TP6U2.js";
 import {
   config
-} from "./chunk-OAXFCOJV.js";
+} from "./chunk-4ZDQXWBT.js";
 import {
+  UnifiedDocsMigrationStatus,
+  pendingInviteSchema,
   teamBillingSummary,
   teamImageSchema,
-  teamNameSchema
-} from "./chunk-4DGQIAJX.js";
+  teamNameSchema,
+  teamSdkPricing,
+  userRefSchema
+} from "./chunk-VNYE4R7N.js";
 import {
   docsProjectSchema,
   githubInstallSchema,
   githubProjectSchema,
-  nanoid,
-  nanoidSchema,
   projectSchema,
-  schemaModel,
-  slugSchema,
   themeSchema
-} from "./chunk-ISGLWBXZ.js";
+} from "./chunk-OQKDBLOZ.js";
 import {
-  external_exports
-} from "./chunk-H2WRMLYY.js";
+  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) {
@@ -139,7 +153,6 @@ var timeseriesPointSchema = external_exports.object({
   human: external_exports.number().int().nonnegative(),
   bot: external_exports.number().int().nonnegative(),
   llm: external_exports.number().int().nonnegative(),
-  mcp: external_exports.number().int().nonnegative(),
   unique: external_exports.number().int().nonnegative()
 });
 var overviewResultSchema = external_exports.object({
@@ -172,8 +185,7 @@ 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(),
-    mcp: external_exports.number().int().nonnegative()
+    llm: external_exports.number().int().nonnegative()
   }),
   timeseries: external_exports.array(timeseriesPointSchema)
 });
@@ -301,6 +313,69 @@ function loginPortalsApiFactory(requestService) {
   };
 }
 
+// ../../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) {
@@ -330,9 +405,8 @@ function managedDocsApiFactory(requestService) {
         description: true,
         namespace: true,
         isPrivate: true,
-        tags: true,
-        versions: true
-      }).array()
+        tags: true
+      }).extend({ versions: managedDocVersionSchema.array() }).array()
     });
   }
   async function getApiDoc(namespace, slug) {
@@ -347,9 +421,8 @@ function managedDocsApiFactory(requestService) {
         description: true,
         namespace: true,
         isPrivate: true,
-        tags: true,
-        versions: true
-      })
+        tags: true
+      }).extend({ versions: managedDocVersionSchema.array() })
     });
   }
   async function listApiDocs() {
@@ -364,23 +437,24 @@ function managedDocsApiFactory(requestService) {
         description: true,
         namespace: true,
         isPrivate: true,
-        tags: true,
-        versions: true
-      }).array()
+        tags: true
+      }).extend({ versions: managedDocVersionSchema.array() }).array()
     });
   }
-  async function create(namespace, data) {
+  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,
+      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(),
-        versionSha: external_exports.string()
+        yamlSha: external_exports.string()
       })
     });
   }
@@ -392,23 +466,28 @@ function managedDocsApiFactory(requestService) {
       schema: external_exports.null()
     });
   }
-  async function addVersion(namespace, slug, data) {
+  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,
+      data: body,
       schema: managedDocVersionSchema
     });
   }
-  async function updateVersion(namespace, slug, semver, data) {
+  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,
+      data: body,
       schema: external_exports.object({
         jsonSha: external_exports.string(),
-        yamlSha: external_exports.string(),
-        versionSha: external_exports.string()
+        yamlSha: external_exports.string()
       })
     });
   }
@@ -510,9 +589,8 @@ function managedSchemasApiFactory(requestService) {
         description: true,
         slug: true,
         namespace: true,
-        isPrivate: true,
-        versions: true
-      }).array()
+        isPrivate: true
+      }).extend({ versions: managedSchemaVersion.array() }).array()
     });
   }
   async function create(namespace, data) {
@@ -550,7 +628,9 @@ function managedSchemasApiFactory(requestService) {
       url: `core/schemas/${namespace}/${slug}/version`,
       method: "post",
       data,
-      schema: external_exports.object({ uid: external_exports.string() })
+      schema: external_exports.object({
+        uid: external_exports.string()
+      })
     });
   }
   async function duplicateVersion(namespace, slug, version, data) {
@@ -566,7 +646,7 @@ function managedSchemasApiFactory(requestService) {
       url: `core/schemas/${namespace}/${slug}/version/${version}`,
       method: "post",
       data,
-      schema: external_exports.null()
+      schema: external_exports.object({ jsonSha: external_exports.string() })
     });
   }
   async function deleteVersion(namespace, slug, version) {
@@ -680,7 +760,7 @@ function registryGitApiFactory(requestService) {
       url: `${base(asset, namespace, slug)}/config`,
       method: "patch",
       data,
-      schema: registryGitBindingSchema
+      schema: external_exports.object({ source: docSourceSchema })
     });
   }
   async function linkExternal(asset, namespace, slug, data) {
@@ -689,7 +769,8 @@ function registryGitApiFactory(requestService) {
       method: "post",
       data,
       schema: external_exports.object({
-        git: registryGitBindingSchema,
+        repository: linkedRepositorySchema,
+        source: docSourceSchema,
         pullRequest: external_exports.object({
           url: external_exports.string(),
           number: external_exports.number(),
@@ -703,13 +784,72 @@ function registryGitApiFactory(requestService) {
       url: `${base(asset, namespace, slug)}/unlink-external`,
       method: "post",
       data: {},
-      schema: registryGitBindingSchema
+      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,
@@ -717,6 +857,73 @@ function registryGitApiFactory(requestService) {
   };
 }
 
+// ../../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) {
@@ -816,6 +1023,27 @@ function rulesApiFactory(requestService) {
 
 // ../../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",
@@ -841,11 +1069,13 @@ function sdksApiFactory(requestService) {
     });
   }
   async function previewCodeSamples(data) {
+    const { signal, ...body } = data;
     return await requestService.request({
       url: "sdk-generator/preview",
       method: "post",
-      data,
-      schema: external_exports.unknown()
+      data: body,
+      schema: external_exports.unknown(),
+      signal
     });
   }
   async function resolveConfig(data) {
@@ -898,6 +1128,18 @@ function sdksApiFactory(requestService) {
       })
     });
   }
+  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`,
@@ -931,10 +1173,14 @@ function sdksApiFactory(requestService) {
     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()
+          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()
       })
     });
@@ -943,6 +1189,7 @@ function sdksApiFactory(requestService) {
     return await requestService.request({
       url: `core/v1/sdks/${data.uid}/sample/retry`,
       method: "post",
+      data: { language: data.language },
       schema: external_exports.null()
     });
   };
@@ -1000,6 +1247,8 @@ function sdksApiFactory(requestService) {
     });
   }
   return {
+    list,
+    get,
     create,
     createVersion,
     previewCodeSamples,
@@ -1010,6 +1259,7 @@ function sdksApiFactory(requestService) {
     discardDraft,
     deleteVersion,
     available,
+    checkRegistryAvailability,
     addAccessGroup,
     removeAccessGroup,
     getReleasePr,
@@ -1125,6 +1375,84 @@ function waitlistApiFactory(requestService) {
   };
 }
 
+// ../../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) {
@@ -1217,6 +1545,18 @@ function formatApiError(message, status, error = null, code, body) {
     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 = {};
@@ -1237,7 +1577,7 @@ function requestServiceFactory(baseUrl, getAuthToken, logger = console) {
         logger.warn("WARNING: Auth token function returned an empty value");
       }
     }
-    const url = (requestUrl.includes("http") ? requestUrl : `${baseUrl}/${requestUrl}`).replace(/([^:]\/)\/+/g, "$1");
+    const url = (/^https?:\/\//i.test(requestUrl) ? requestUrl : `${baseUrl}/${requestUrl}`).replace(/([^:]\/)\/+/g, "$1");
     const method = config2.method === "patch" ? "PATCH" : config2.method;
     return fetch(url, {
       ...config2,
@@ -1271,6 +1611,17 @@ function requestServiceFactory(baseUrl, getAuthToken, logger = console) {
         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);
     });
@@ -1504,6 +1855,20 @@ function bitbucketApiFactory(requestService) {
 
 // ../../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",
@@ -1527,6 +1892,33 @@ function docsProjectApiFactory(requestService) {
       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",
@@ -1552,11 +1944,12 @@ function docsProjectApiFactory(requestService) {
       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
       })
     });
@@ -1593,6 +1986,14 @@ function docsProjectApiFactory(requestService) {
       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`,
@@ -1601,16 +2002,20 @@ function docsProjectApiFactory(requestService) {
     });
   }
   return {
+    listProjects,
     createProject,
     deleteProject,
     getProject,
+    getConfig,
+    putConfig,
     getGitCredentials,
     updateRepoSettings,
     linkGithub,
     unlinkGithub,
     linkBitbucket,
     unlinkBitbucket,
-    refreshBitbucketWebhook
+    refreshBitbucketWebhook,
+    switchRepository
   };
 }
 
@@ -2078,7 +2483,7 @@ function publishApiFactory(requestService) {
       schema: external_exports.object({ publishUid: nanoidSchema })
     });
   }
-  async function publishDocsProject({ slug, configPath, preview, commitSha }) {
+  async function publishDocsProject({ slug, configPath, preview, pullRequestComments, commitSha }) {
     return await requestService.request({
       url: "publish-deploy/publish/docs-project",
       method: "post",
@@ -2086,6 +2491,7 @@ function publishApiFactory(requestService) {
         slug,
         configPath,
         preview,
+        pullRequestComments,
         commitSha
       },
       schema: external_exports.object({ publishUid: nanoidSchema })
@@ -2341,6 +2747,16 @@ function teamApiFactory(requestService, getNewTokens) {
       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",
@@ -2424,6 +2840,16 @@ function teamApiFactory(requestService, getNewTokens) {
       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",
@@ -2500,6 +2926,13 @@ function teamApiFactory(requestService, getNewTokens) {
       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",
@@ -2619,14 +3052,17 @@ function teamApiFactory(requestService, getNewTokens) {
   return {
     list,
     create,
+    getMembers,
     inviteMember,
     removeInvite,
     resendInvite,
     rename,
+    requestUnifiedDocsMigration,
     leave,
     removeMember,
     delete: deleteTeam,
     getBillingSummary,
+    getSdkPricing,
     updateBillingEmail,
     updateBillingPlan,
     extendTrial,
@@ -2675,8 +3111,10 @@ var apiServiceFactory = (baseUrl, getAuthToken, getNewTokens) => {
     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),
@@ -2686,8 +3124,8 @@ var apiServiceFactory = (baseUrl, getAuthToken, getNewTokens) => {
 };
 
 // src/helpers/api-service.ts
-var apiService = async () => {
-  const auth = await getAuthData();
+var apiService = async (opts) => {
+  const auth = await getAuthData(opts);
   auth.addEventListener((state) => Object.assign(auth, state));
   return apiServiceFactory(
     config.services.api,