@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-OQKDBLOZ.js

@@ -0,0 +1,741 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  entitySchema,
+  external_exports,
+  namespaceSchema,
+  nanoid,
+  nanoidSchema,
+  scalarSet,
+  slugSchema,
+  timestampSchema
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/entities/dist/project/active-deployment.js
+var activeDeploymentSchema = external_exports.object({
+  /** uid of the publish record for the last successful deployment */
+  uid: external_exports.string(),
+  /** subdomain or custom domain */
+  domain: external_exports.string(),
+  /** timestamp of the last successful deployment */
+  publishedAt: timestampSchema
+}).meta({ id: "active-deployment" });
+
+// ../../packages/entities/dist/project/icon.js
+var projectIconDefinitionSchema = external_exports.object({
+  /** Key to local icon OR URL to hosted icon */
+  src: external_exports.string().default(""),
+  /** Image alt or svg title */
+  title: external_exports.string().optional(),
+  /** Mask a non-svg image */
+  mask: external_exports.boolean().optional(),
+  /** Search and group tags */
+  tags: external_exports.string().array().default([]),
+  /** Sorting group in list */
+  group: external_exports.string().default("")
+}).meta({ id: "project-icon-definition" });
+var customProjectIconSchema = projectIconDefinitionSchema.extend({
+  /** Timestamp for when the icon was uploaded */
+  createdAt: timestampSchema,
+  /** User ID who uploaded the icon */
+  uploadedBy: external_exports.string(),
+  /** Always a custom icon */
+  group: external_exports.literal("custom")
+}).meta({ id: "custom-project-icon" });
+var projectIconInfoSchema = external_exports.object({
+  src: external_exports.string().default(""),
+  title: external_exports.string().optional(),
+  mask: external_exports.boolean().optional()
+}).meta({ id: "project-icon-info" });
+var projectIconSchema = external_exports.preprocess((arg) => {
+  if (!arg)
+    return arg;
+  if (!arg.src)
+    arg.src = arg.local || arg.remote;
+  if (arg.local)
+    arg.group = "solid";
+  if (arg.remote)
+    arg.group = "custom";
+  return arg;
+}, projectIconInfoSchema).meta({ id: "project-icon" });
+
+// ../../packages/entities/dist/project/version/sidebar.js
+var SidebarType;
+(function(SidebarType2) {
+  SidebarType2["Page"] = "Page";
+  SidebarType2["Folder"] = "Folder";
+  SidebarType2["Link"] = "Link";
+})(SidebarType || (SidebarType = {}));
+var baseSidebarItemSchema = external_exports.object({
+  uid: nanoidSchema,
+  title: external_exports.string().trim().min(1),
+  type: external_exports.enum(SidebarType),
+  link: external_exports.string().optional(),
+  icon: projectIconSchema.optional(),
+  children: external_exports.string().array().optional(),
+  description: external_exports.string().optional(),
+  show: external_exports.boolean()
+}).meta({ id: "base-sidebar-item" });
+var linkSchema = baseSidebarItemSchema.extend({
+  title: external_exports.preprocess((arg) => arg?.trim() || "Link", external_exports.string().trim().min(1)),
+  link: external_exports.string(),
+  type: external_exports.literal(SidebarType.Link)
+}).meta({ id: "sidebar-link" });
+var pageSchema = baseSidebarItemSchema.extend({
+  title: external_exports.preprocess((arg) => arg?.trim() || "Page", external_exports.string().trim().min(1)),
+  sidebarTitle: external_exports.string().optional(),
+  description: external_exports.string(),
+  children: external_exports.string().array().default([]),
+  type: external_exports.literal(SidebarType.Page),
+  defaultOpen: external_exports.boolean().optional(),
+  yjsReference: external_exports.string(),
+  backgroundImage: external_exports.string().optional(),
+  icon: projectIconSchema.optional(),
+  /**
+   * Automatically set during sync builds when we map markdown and mdx files to pages
+   *
+   * Used by the Vue builds to determine how to render a given page item.
+   */
+  isMdx: external_exports.boolean().default(false),
+  /**
+   * Automatically set during sync builds when we map HTML files to pages.
+   */
+  isHtml: external_exports.boolean().default(false)
+}).meta({ id: "sidebar-page" });
+var defaultPage = () => ({
+  uid: nanoid(),
+  title: "Getting Started",
+  type: SidebarType.Page,
+  description: "Start writing your API Documentation with our platform",
+  children: [],
+  show: true,
+  yjsReference: nanoid(),
+  isMdx: false,
+  isHtml: false
+});
+var folderSchema = baseSidebarItemSchema.extend({
+  title: external_exports.preprocess((arg) => arg?.trim() || "Folder", external_exports.string().trim().min(1)),
+  children: external_exports.string().array().default([]),
+  type: external_exports.literal(SidebarType.Folder),
+  defaultOpen: external_exports.boolean().optional()
+}).meta({ id: "sidebar-folder" });
+var sidebarItemSchema = external_exports.union([linkSchema, pageSchema, folderSchema]).meta({ id: "sidebar-item" });
+var sidebarSchema = external_exports.object({
+  /** Complete record of ALL sidebar items */
+  items: external_exports.record(external_exports.string(), sidebarItemSchema),
+  /** Ordered list of the direct children */
+  children: external_exports.string().array()
+}).overwrite((val) => {
+  const hasPage = Object.values(val.items).some((item) => item.type === SidebarType.Page);
+  if (!hasPage) {
+    const firstPage = defaultPage();
+    val.items[firstPage.uid] = firstPage;
+    val.children.push(firstPage.uid);
+  }
+  return val;
+}).meta({ id: "sidebar" });
+
+// ../../packages/entities/dist/project/footer.js
+var defaultFooter = `<footer>
+  <div class="footer-content">
+    <p>This documentation playground was created by Scalar. For help, questions or feedback don't hesitate to <a href="mailto:support@scalar.com">email our support.</a></p>
+    <br />
+    <p>You can fully customize or delete this footer by simply navigating to the footer section of the "customize" button  within our header.</p>
+    <br />
+    <a target="_blank" href="https://scalar.com/#docs">Features</a>
+    <a target="_blank" href="https://scalar.com/#docs">About</a>
+    <a target="_blank" href="https://scalar.com/#pricing">Pricing</a>
+    <br />
+    <a target="_blank" href="https://scalar.com/privacy-policy">Privacy Policy</a>
+    <a target="_blank" href="https://scalar.com/terms-and-conditions">Terms of Service</a>
+    <a target="_blank" href="https://scalar.com/#pricing">Pricing</a>
+    <br />
+    <p>\xA9 ${(/* @__PURE__ */ new Date()).getFullYear()} Scalar</p>
+  </div>
+</footer>`;
+var defaultFooterCSS = `footer {
+  display: flex;
+  flex-direction: column;
+  font-size: var(--scalar-paragraph);
+  line-height: 1.625;
+  border-top: var(--scalar-border-width) solid var(--scalar-border-color);
+}
+footer p {
+  margin-bottom: 25px;
+}
+footer a {
+  width: fit-content;
+  color:var(--scalar-color-accent)
+}
+footer a:hover {
+  cursor: pointer;
+  text-decoration: underline;
+}
+.footer-content {
+  margin: 0 auto;
+  padding: 50px;
+}  
+@media (max-width: 1000px) {
+  footer {
+    max-width: 100%;
+  }
+}
+`;
+
+// ../../packages/entities/dist/project/header-links.js
+var headerLinkBaseSchema = external_exports.object({
+  uid: nanoidSchema,
+  title: external_exports.string(),
+  show: external_exports.boolean().default(true),
+  isStarred: external_exports.boolean().default(false),
+  type: external_exports.union([
+    external_exports.literal("guide"),
+    external_exports.literal("reference"),
+    external_exports.literal("link"),
+    external_exports.literal("group"),
+    external_exports.literal("version-selector"),
+    external_exports.literal("spacer")
+  ]).default("link")
+}).meta({ id: "header-link-base" });
+var headerLinkReferenceSchema = headerLinkBaseSchema.extend({
+  type: external_exports.literal("reference"),
+  /** Whether the reference has a permalinked reference or not */
+  hasPermalink: external_exports.boolean().default(false).describe("Whether the reference has a permalinked reference or not"),
+  hasManagedDoc: external_exports.boolean().default(false).describe("Whether the reference has a linked registry API")
+}).meta({ id: "header-link-reference" });
+var headerLinkGuideSchema = headerLinkBaseSchema.extend({
+  type: external_exports.literal("guide")
+}).meta({ id: "header-link-guide" });
+var headerLinkVersionSelectorSchema = headerLinkBaseSchema.extend({
+  type: external_exports.literal("version-selector")
+}).meta({ id: "header-link-version-selector" });
+var headerLinkSpacerSchema = headerLinkBaseSchema.extend({
+  type: external_exports.literal("spacer")
+}).meta({ id: "header-link-spacer" });
+var headerLinkExternalSchema = headerLinkBaseSchema.extend({
+  type: external_exports.literal("link"),
+  isButton: external_exports.boolean().default(false),
+  link: external_exports.string()
+}).meta({ id: "header-link-external" });
+var headerLinkGroupSchema = headerLinkBaseSchema.extend({
+  type: external_exports.literal("group"),
+  /** Children of the group. Groups cannot contain other groups, spacers, or the version selector */
+  children: external_exports.array(external_exports.union([
+    headerLinkGuideSchema,
+    headerLinkReferenceSchema,
+    headerLinkExternalSchema
+  ])).describe("Children of the group. Groups cannot contain other groups, spacers, or the version selector")
+}).meta({ id: "header-link-group" });
+var headerLinkSchema = external_exports.union([
+  headerLinkGuideSchema,
+  headerLinkReferenceSchema,
+  headerLinkGroupSchema,
+  headerLinkExternalSchema,
+  headerLinkVersionSelectorSchema,
+  headerLinkSpacerSchema
+]).meta({ id: "header-link" });
+function getHeaderLinks({ guides, references, header }) {
+  const complete = [...header].filter((h) => {
+    if (h.type === "guide")
+      return !!guides[h.uid];
+    if (h.type === "reference")
+      return !!references[h.uid];
+    return true;
+  }).map((header2) => {
+    if (header2.type !== "group")
+      return header2;
+    return {
+      ...header2,
+      // Only include header children if the guide/reference is available
+      children: header2.children.filter((c) => {
+        if (c.type === "guide")
+          return !!guides[c.uid];
+        if (c.type === "reference")
+          return !!references[c.uid];
+        return true;
+      })
+    };
+  });
+  const orderedIds = [];
+  complete.forEach((h) => {
+    orderedIds.push(h.uid);
+    if (h.type === "group") {
+      orderedIds.push(...h.children.map((c) => c.uid));
+    }
+  });
+  Object.values(guides).forEach((g) => {
+    if (!orderedIds.includes(g.uid)) {
+      complete.push({
+        uid: g.uid,
+        title: g.title,
+        show: g.show,
+        isStarred: g.isStarred,
+        type: "guide"
+      });
+    }
+  });
+  Object.values(references).forEach((r) => {
+    if (!orderedIds.includes(r.uid)) {
+      complete.push({
+        uid: r.uid,
+        title: r.title,
+        show: r.show,
+        isStarred: r.isStarred,
+        type: "reference",
+        hasPermalink: !!r.specPermalink,
+        hasManagedDoc: !!r.managedDoc
+      });
+    }
+  });
+  if (!complete.find((e) => e.type === "version-selector")) {
+    complete.push({
+      uid: nanoid(),
+      title: "Version Selector",
+      type: "version-selector",
+      show: true,
+      isStarred: false
+    });
+  }
+  complete.forEach((element) => {
+    const guide = guides[element.uid];
+    const reference = references[element.uid];
+    if (element.type === "guide" && guide) {
+      element.title = guide.title;
+      element.show = guide.show;
+      element.isStarred = guide.isStarred;
+    }
+    if (element.type === "reference" && reference) {
+      element.title = reference.title;
+      element.show = reference.show;
+      element.isStarred = reference.isStarred;
+      element.hasPermalink = !!reference.specPermalink;
+      element.hasManagedDoc = !!reference.managedDoc;
+    }
+    if (element.type === "group") {
+      element.children.forEach((c) => {
+        const childGuide = guides[c.uid];
+        const childReference = references[c.uid];
+        if (c.type === "guide" && childGuide) {
+          c.title = childGuide.title;
+          c.show = childGuide.show;
+          c.isStarred = childGuide.isStarred;
+        }
+        if (c.type === "reference" && childReference) {
+          c.title = childReference.title;
+          c.show = childReference.show;
+          c.isStarred = childReference.isStarred;
+          c.hasPermalink = !!childReference.specPermalink;
+          c.hasManagedDoc = !!childReference.managedDoc;
+        }
+      });
+    }
+  });
+  return complete;
+}
+
+// ../../packages/entities/dist/project/version/guide.js
+var guideSchema = external_exports.object({
+  /** Unique identifier for the guide */
+  uid: nanoidSchema,
+  /** Title of the guide */
+  title: external_exports.string().overwrite((val) => val === "" ? "Guide" : val),
+  /** Description of the guide */
+  description: external_exports.string(),
+  /** Sidebar configuration for the guide */
+  sidebar: sidebarSchema,
+  /** Whether to publish the guide or not */
+  show: external_exports.boolean().default(true),
+  /** Option to show the header link as a button */
+  isButton: external_exports.boolean().default(false),
+  /** Option to force the header link to the top nav */
+  isStarred: external_exports.boolean().default(false)
+}).meta({ id: "guide" });
+function defaultGuide() {
+  const firstPage = defaultPage();
+  return guideSchema.parse({
+    uid: nanoid(),
+    title: "Guide",
+    description: "",
+    sidebar: {
+      items: {
+        [firstPage.uid]: firstPage
+      },
+      children: [firstPage.uid]
+    },
+    show: true,
+    isButton: false,
+    isStarred: false
+  });
+}
+
+// ../../packages/entities/dist/project/version/reference.js
+var referenceManagedDocSchema = external_exports.object({
+  /** API namespace */
+  namespace: namespaceSchema,
+  /** API slug */
+  slug: slugSchema,
+  /** Selected versions to display */
+  versions: external_exports.string().array().default(["latest"])
+}).meta({ id: "reference-managed-doc" });
+var referenceSchema = external_exports.object({
+  /** Unique identifier for the reference */
+  uid: nanoidSchema,
+  /** Title of the reference */
+  title: external_exports.string().overwrite((val) => val === "" ? "Reference" : val),
+  /** Description of the reference */
+  description: external_exports.string(),
+  /** Yjs reference id for the reference */
+  yjsReference: nanoidSchema,
+  /** Config for the reference */
+  config: external_exports.string().default("{}"),
+  /** Optional permalink for the reference */
+  specPermalink: external_exports.string().default(""),
+  /** Optional registry API */
+  managedDoc: referenceManagedDocSchema.nullable().default(null),
+  /** Whether to publish the reference or not */
+  show: external_exports.boolean().default(true),
+  /** Option to show the header link as a button */
+  isButton: external_exports.boolean().default(false),
+  /** Option to force the header link to the top nav */
+  isStarred: external_exports.boolean().default(false)
+}).meta({ id: "reference" });
+function defaultReference() {
+  return referenceSchema.parse({
+    uid: nanoid(),
+    title: "",
+    description: "",
+    yjsReference: nanoid()
+  });
+}
+
+// ../../packages/entities/dist/project/version/version.js
+var versionSchema = external_exports.object({
+  uid: nanoidSchema,
+  name: external_exports.string().default("Default Version"),
+  primaryGuideId: external_exports.string(),
+  primaryReferenceId: external_exports.string(),
+  references: external_exports.record(external_exports.string(), referenceSchema),
+  guides: external_exports.record(external_exports.string(), guideSchema),
+  header: headerLinkSchema.array(),
+  footer: external_exports.string().default(""),
+  footerCss: external_exports.string().default(""),
+  footerBelowSidebar: external_exports.boolean().default(false),
+  headScript: external_exports.string().default(""),
+  bodyScript: external_exports.string().default("")
+}).overwrite((v) => {
+  return {
+    ...v,
+    header: getHeaderLinks({
+      guides: v.guides,
+      references: v.references,
+      header: v.header
+    })
+  };
+}).meta({ id: "project-version" });
+function defaultVersion(initialState = {}, options = {}) {
+  const guide = defaultGuide();
+  const reference = defaultReference();
+  if (options.hideGuide)
+    guide.show = false;
+  if (options.hideReference)
+    reference.show = false;
+  return versionSchema.parse({
+    uid: nanoid(),
+    name: "Version 0",
+    primaryGuideId: guide.uid,
+    primaryReferenceId: reference.uid,
+    references: { [reference.uid]: reference },
+    guides: { [guide.uid]: guide },
+    header: getHeaderLinks({
+      guides: { [guide.uid]: guide },
+      references: { [reference.uid]: reference },
+      header: []
+    }),
+    footer: defaultFooter,
+    footerCss: defaultFooterCSS,
+    footerBelowSidebar: false,
+    headScript: "",
+    bodyScript: "",
+    ...initialState
+  });
+}
+
+// ../../packages/entities/dist/project/website.js
+var websiteSchema = external_exports.object({
+  lastDeployed: timestampSchema,
+  subdomainPrefix: external_exports.string().overwrite((val) => val.toLowerCase()),
+  customUrl: external_exports.string().overwrite((val) => val.toLowerCase()),
+  subPath: external_exports.string().optional(),
+  title: external_exports.string().optional(),
+  description: external_exports.string().optional(),
+  favicon: external_exports.string().optional(),
+  ogImage: external_exports.string().optional(),
+  proxy: external_exports.url().optional(),
+  routing: external_exports.object({
+    /**
+     * Path replacement pattern for guides.
+     * Defaults to `{{version}}/{{guide}}` with version dropped when there is only a single version.
+     */
+    guidePathPattern: external_exports.string().optional(),
+    /**
+     * Path replacement pattern for references.
+     * Defaults to `{{version}}/{{reference}}` with version dropped when there is only a single version.
+     */
+    referencePathPattern: external_exports.string().optional()
+  }).default({
+    guidePathPattern: "",
+    referencePathPattern: ""
+  }),
+  redirects: external_exports.array(external_exports.object({
+    from: external_exports.string(),
+    to: external_exports.string()
+  })).default([])
+}).meta({ id: "website" });
+
+// ../../packages/entities/dist/project/project.js
+var logoSchema = external_exports.object({
+  darkMode: external_exports.string(),
+  lightMode: external_exports.string()
+}).meta({ id: "logo" });
+var sharedProjectSchema = entitySchema.extend({
+  /** Name of the project */
+  name: external_exports.string(),
+  /** Record of the last successful deployment */
+  activeDeployment: activeDeploymentSchema.nullable().default(null),
+  /** Track last published timestamp to allow build interrupts */
+  lastPublished: timestampSchema.nullable().default(null),
+  /** Uid of the most recent publish record (failed or successful) */
+  lastPublishedUid: external_exports.string().nullable().default(null),
+  /** Uid of the login portal customization object for private projects */
+  loginPortalUid: external_exports.string().default(""),
+  /** Active theme id for the project */
+  activeThemeId: external_exports.string().default(""),
+  /** Typesense id for the project */
+  typesenseId: external_exports.number().optional(),
+  /** Private projects require a login from a user in an access group */
+  isPrivate: external_exports.boolean().default(false),
+  /** Toggle AI agent features for the docs project */
+  agentEnabled: external_exports.boolean().default(false),
+  /** Toggle analytics tracking for the docs project */
+  analyticsEnabled: external_exports.boolean().default(true),
+  /** Set of allowed access groups */
+  accessGroups: scalarSet(external_exports.set(nanoidSchema).max(50)).default([])
+}).meta({ id: "shared-project" });
+var projectSchema = sharedProjectSchema.extend({
+  /** Versions of the project */
+  versions: external_exports.record(external_exports.string(), versionSchema),
+  /** Active template id for the project */
+  activeTemplateId: external_exports.string().optional().default(""),
+  /** Active version id for the project */
+  activeVersionId: external_exports.string().optional().default(""),
+  /** Logo for the project */
+  logo: logoSchema,
+  /** Deployed site configuration for a project */
+  website: websiteSchema.describe("Deployed site configuration for a project"),
+  insertPageTitles: external_exports.boolean().optional().default(true)
+}).overwrite((project) => {
+  if (Object.keys(project.versions).length === 0) {
+    const v = defaultVersion({});
+    project.versions[v.uid] = v;
+  }
+  if (!project.activeVersionId) {
+    project.activeVersionId = Object.keys(project.versions)[0] ?? "";
+  }
+  return project;
+}).meta({ id: "project" });
+var githubProjectRepositorySchema = external_exports.object({
+  linkedBy: external_exports.string(),
+  id: external_exports.number(),
+  name: external_exports.string().min(2),
+  configPath: external_exports.string().default(""),
+  branch: external_exports.string().default(""),
+  publishOnMerge: external_exports.boolean().default(false),
+  publishPreviews: external_exports.boolean().default(false),
+  prComments: external_exports.boolean().default(false),
+  /** One-time repository expired tracking */
+  expired: external_exports.boolean().default(false)
+}).meta({ id: "github-project-repository" });
+var githubInstallSchema = external_exports.object({
+  id: external_exports.number().int(),
+  name: external_exports.string(),
+  icon: external_exports.string().optional(),
+  repos: external_exports.object({
+    id: external_exports.number().int(),
+    name: external_exports.string(),
+    /**
+     * The repository's default branch. Optional because a cached response
+     * predating this field parses without it, and callers fall back to
+     * whatever the server resolves at link time.
+     */
+    defaultBranch: external_exports.string().optional()
+  }).array()
+}).meta({ id: "github-install" });
+var githubProjectSchema = sharedProjectSchema.extend({
+  slug: slugSchema,
+  /** Last publish status info */
+  publishStatus: external_exports.string().default(""),
+  /** Last publish output message */
+  publishMessage: external_exports.string().default(""),
+  /**
+   *
+   * Reference info for the link repository
+   *
+   * Optional for projects which are not linked
+   */
+  repository: githubProjectRepositorySchema.nullable().optional()
+}).meta({ id: "github-project" });
+var forgejoRepositorySchema = external_exports.object({
+  provider: external_exports.literal("forgejo"),
+  forgejoOwner: external_exports.string(),
+  forgejoRepo: external_exports.string(),
+  branch: external_exports.string().default("main"),
+  configPath: external_exports.string().default("scalar.config.json")
+}).meta({ id: "docs-project-repository-forgejo" });
+var githubRepositorySchema = external_exports.object({
+  provider: external_exports.literal("github"),
+  linkedBy: external_exports.string(),
+  installationId: external_exports.number().int(),
+  id: external_exports.number().int(),
+  name: external_exports.string().min(2),
+  /**
+   * The team's shared linked-repository record for this remote, so a docs
+   * project and a registry document on the same customer repo share one
+   * record (and one internal mirror). Null until the backfill stamps it.
+   * The embedded remote fields above mirror the record; `branch`,
+   * `configPath` and the publish flags below describe how this project uses
+   * the repo and stay here.
+   */
+  repositoryUid: nanoidSchema.brand().nullable().default(null),
+  branch: external_exports.string().default("main"),
+  configPath: external_exports.string().default("scalar.config.json"),
+  publishOnMerge: external_exports.boolean().default(true),
+  publishPreviews: external_exports.boolean().default(false),
+  prComments: external_exports.boolean().default(false),
+  expired: external_exports.boolean().default(false)
+}).meta({ id: "docs-project-repository-github" });
+var bitbucketRepositorySchema = external_exports.object({
+  provider: external_exports.literal("bitbucket"),
+  linkedBy: external_exports.string(),
+  workspaceUuid: external_exports.string(),
+  workspaceSlug: external_exports.string(),
+  repoUuid: external_exports.string(),
+  repoSlug: external_exports.string(),
+  /** `workspaceSlug/repoSlug` for display, mirrored from GitHub for symmetry */
+  name: external_exports.string().min(2),
+  /** The shared linked-repository record; wired when Bitbucket linking is. */
+  repositoryUid: nanoidSchema.brand().nullable().default(null),
+  branch: external_exports.string().default("main"),
+  configPath: external_exports.string().default("scalar.config.json"),
+  publishOnMerge: external_exports.boolean().default(true),
+  publishPreviews: external_exports.boolean().default(false),
+  prComments: external_exports.boolean().default(false),
+  expired: external_exports.boolean().default(false),
+  /**
+   * The Scalar hook this project was pointed at when it linked. Hooks are
+   * shared by every project on the repository, so this may name a hook a
+   * later link collapsed away; the hook is only deleted once no project is
+   * left on the repository.
+   */
+  webhookUuid: external_exports.string().default("")
+}).meta({ id: "docs-project-repository-bitbucket" });
+var docsProjectRepositorySchema = external_exports.discriminatedUnion("provider", [
+  forgejoRepositorySchema,
+  githubRepositorySchema,
+  bitbucketRepositorySchema
+]);
+var remoteActivitySchema = external_exports.object({
+  at: timestampSchema,
+  branch: external_exports.string().nullable(),
+  sha: external_exports.string().nullable(),
+  actorName: external_exports.string().nullable()
+}).meta({ id: "docs-project-remote-activity" });
+var docsProjectSchema = sharedProjectSchema.extend({
+  slug: slugSchema,
+  publishStatus: external_exports.string().default(""),
+  publishMessage: external_exports.string().default(""),
+  repository: docsProjectRepositorySchema,
+  /**
+   * `.catch(undefined)` so a malformed bump degrades to "no signal" instead
+   * of failing the schema parse inside every subscribed dashboard.
+   */
+  remoteActivity: remoteActivitySchema.optional().catch(void 0)
+}).meta({ id: "docs-project" });
+function isGithubBackedDocsProject(project) {
+  return project.repository.provider === "github";
+}
+
+// ../../packages/entities/dist/project/publish.js
+var ConfigVersion;
+(function(ConfigVersion2) {
+  ConfigVersion2["V1"] = "1.0.0";
+  ConfigVersion2["V2"] = "2.0.0";
+})(ConfigVersion || (ConfigVersion = {}));
+var publishRecordSchema = entitySchema.extend({
+  projectUid: nanoidSchema,
+  status: external_exports.union([
+    external_exports.literal("pending"),
+    external_exports.literal("building"),
+    external_exports.literal("deployed"),
+    external_exports.literal("inactive"),
+    external_exports.literal("error"),
+    external_exports.literal("deleted"),
+    external_exports.literal("cancelled")
+  ]),
+  deployedAt: external_exports.number().nullable().default(null),
+  message: external_exports.string().default(""),
+  domain: external_exports.string().default(""),
+  preview: external_exports.boolean().optional().default(false),
+  /**
+   * Whether this publish may comment its preview URL on the pull requests
+   * that contain its commit. Resolved from the project's config when the
+   * publish is triggered, because the build finishes long after the trigger
+   * and the config may have moved on by then.
+   *
+   * Opt-out, not opt-in: a project that never states a preference keeps the
+   * comments, and records written before this field existed parse as `true`.
+   */
+  pullRequestComments: external_exports.boolean().optional().default(true),
+  commitSha: external_exports.string().nullable().default(null),
+  version: external_exports.enum(ConfigVersion).default(ConfigVersion.V1),
+  isWysiwyg: external_exports.boolean().default(false),
+  unifiedDocs: external_exports.boolean().default(false),
+  subpath: external_exports.string().nullable().default(null),
+  configPath: external_exports.string().optional().default("scalar.config.json"),
+  registryApis: external_exports.object({
+    uid: nanoidSchema,
+    version: external_exports.string()
+  }).array().optional().default([]),
+  agentToken: external_exports.string().nullable().default(null)
+}).meta({ id: "publish-record" });
+
+// ../../packages/entities/dist/theme/index.js
+var themeSchema = external_exports.object({
+  uid: nanoidSchema,
+  name: external_exports.string(),
+  description: external_exports.string(),
+  theme: external_exports.string(),
+  slug: slugSchema
+}).meta({ id: "theme" });
+
+// ../../packages/entities/dist/project/signup.js
+var signupDataSchema = external_exports.object({
+  uid: nanoidSchema,
+  version: versionSchema,
+  theme: themeSchema.optional(),
+  yjsDocs: external_exports.record(external_exports.string(), external_exports.string()),
+  yjsReferences: external_exports.record(external_exports.string(), external_exports.string())
+}).meta({ id: "signup-data" });
+
+export {
+  activeDeploymentSchema,
+  customProjectIconSchema,
+  SidebarType,
+  sharedProjectSchema,
+  projectSchema,
+  githubInstallSchema,
+  githubProjectSchema,
+  docsProjectSchema,
+  isGithubBackedDocsProject,
+  ConfigVersion,
+  publishRecordSchema,
+  themeSchema
+};