@supernova-studio/client 0.48.13 → 0.48.14

package/dist/index.mjs

@@ -20,12 +20,12 @@ import { z as z11 } from "zod";
 import { z as z12 } from "zod";
 import { z as z13 } from "zod";
 import { z as z14 } from "zod";
-import { z as z122 } from "zod";
+import { z as z123 } from "zod";
 import { z as z17 } from "zod";
 import { z as z15 } from "zod";
 import { z as z16 } from "zod";
+import { z as z122 } from "zod";
 import { z as z121 } from "zod";
-import { z as z120 } from "zod";
 import { z as z18 } from "zod";
 import { z as z19 } from "zod";
 import { z as z20 } from "zod";
@@ -113,31 +113,32 @@ import { z as z101 } from "zod";
 import { z as z102 } from "zod";
 import { z as z103 } from "zod";
 import { z as z104 } from "zod";
-import { z as z105 } from "zod";
 import { z as z106 } from "zod";
+import { z as z105 } from "zod";
+import slugifyImplementation from "@sindresorhus/slugify";
 import { z as z107 } from "zod";
 import { z as z108 } from "zod";
 import { z as z109 } from "zod";
+import { z as z110 } from "zod";
+import { z as z115 } from "zod";
 import { z as z114 } from "zod";
-import { z as z113 } from "zod";
 import IPCIDR from "ip-cidr";
-import { z as z112 } from "zod";
-import { z as z110 } from "zod";
+import { z as z113 } from "zod";
 import { z as z111 } from "zod";
-import { z as z115 } from "zod";
+import { z as z112 } from "zod";
 import { z as z116 } from "zod";
 import { z as z117 } from "zod";
 import { z as z118 } from "zod";
 import { z as z119 } from "zod";
+import { z as z120 } from "zod";
+import { z as z130 } from "zod";
 import { z as z129 } from "zod";
-import { z as z128 } from "zod";
-import { z as z123 } from "zod";
 import { z as z124 } from "zod";
 import { z as z125 } from "zod";
 import { z as z126 } from "zod";
 import { z as z127 } from "zod";
+import { z as z128 } from "zod";
 import { z as z142 } from "zod";
-import { z as z130 } from "zod";
 import { z as z131 } from "zod";
 import { z as z132 } from "zod";
 import { z as z133 } from "zod";
@@ -146,10 +147,9 @@ import { z as z135 } from "zod";
 import { z as z136 } from "zod";
 import { z as z137 } from "zod";
 import { z as z138 } from "zod";
+import { z as z139 } from "zod";
 import { z as z141 } from "zod";
 import { z as z140 } from "zod";
-import { z as z139 } from "zod";
-import slugifyImplementation from "@sindresorhus/slugify";
 import { z as z143 } from "zod";
 import { z as z144 } from "zod";
 import { z as z145 } from "zod";
@@ -2475,578 +2475,6 @@ var DocumentationCommentThread = z104.object({
   createdAt: z104.coerce.date(),
   updatedAt: z104.coerce.date()
 });
-var DesignElementSnapshotReason = z105.enum(["Publish", "Deletion"]);
-var DesignElementSnapshotBase = z105.object({
-  id: z105.string(),
-  persistentId: z105.string(),
-  designSystemVersionId: z105.string(),
-  createdAt: z105.coerce.date(),
-  updatedAt: z105.coerce.date(),
-  reason: DesignElementSnapshotReason,
-  createdByUserId: z105.string()
-});
-var DocumentationPageSnapshot = DesignElementSnapshotBase.extend({
-  page: DocumentationPageV2,
-  pageContentHash: z106.string(),
-  pageContentStorageKey: z106.string()
-});
-var ElementGroupSnapshot = DesignElementSnapshotBase.extend({
-  group: ElementGroup
-});
-var ElementViewBaseColumnType = z107.enum(["Name", "Description", "Value", "UpdatedAt"]);
-var ElementViewColumnType = z107.union([
-  z107.literal("BaseProperty"),
-  z107.literal("PropertyDefinition"),
-  z107.literal("Theme")
-]);
-var ElementViewColumnSharedAttributes = z107.object({
-  id: z107.string(),
-  persistentId: z107.string(),
-  elementDataViewId: z107.string(),
-  sortPosition: z107.number(),
-  width: z107.number()
-});
-var ElementViewBasePropertyColumn = ElementViewColumnSharedAttributes.extend({
-  type: z107.literal("BaseProperty"),
-  basePropertyType: ElementViewBaseColumnType
-});
-var ElementViewPropertyDefinitionColumn = ElementViewColumnSharedAttributes.extend({
-  type: z107.literal("PropertyDefinition"),
-  propertyDefinitionId: z107.string()
-});
-var ElementViewThemeColumn = ElementViewColumnSharedAttributes.extend({
-  type: z107.literal("Theme"),
-  themeId: z107.string()
-});
-var ElementViewColumn = z107.discriminatedUnion("type", [
-  ElementViewBasePropertyColumn,
-  ElementViewPropertyDefinitionColumn,
-  ElementViewThemeColumn
-]);
-var ElementView = z108.object({
-  id: z108.string(),
-  persistentId: z108.string(),
-  designSystemVersionId: z108.string(),
-  name: z108.string(),
-  description: z108.string(),
-  targetElementType: ElementPropertyTargetType,
-  isDefault: z108.boolean()
-});
-var Brand = z109.object({
-  id: z109.string(),
-  designSystemVersionId: z109.string(),
-  persistentId: z109.string(),
-  name: z109.string(),
-  description: z109.string()
-});
-var NpmRegistryAuthType = z110.enum(["Basic", "Bearer", "None", "Custom"]);
-var NpmRegistryType = z110.enum(["NPMJS", "GitHub", "AzureDevOps", "Artifactory", "Custom"]);
-var NpmRegistryBasicAuthConfig = z110.object({
-  authType: z110.literal(NpmRegistryAuthType.Enum.Basic),
-  username: z110.string(),
-  password: z110.string()
-});
-var NpmRegistryBearerAuthConfig = z110.object({
-  authType: z110.literal(NpmRegistryAuthType.Enum.Bearer),
-  accessToken: z110.string()
-});
-var NpmRegistryNoAuthConfig = z110.object({
-  authType: z110.literal(NpmRegistryAuthType.Enum.None)
-});
-var NpmRegistrCustomAuthConfig = z110.object({
-  authType: z110.literal(NpmRegistryAuthType.Enum.Custom),
-  authHeaderName: z110.string(),
-  authHeaderValue: z110.string()
-});
-var NpmRegistryAuthConfig = z110.discriminatedUnion("authType", [
-  NpmRegistryBasicAuthConfig,
-  NpmRegistryBearerAuthConfig,
-  NpmRegistryNoAuthConfig,
-  NpmRegistrCustomAuthConfig
-]);
-var NpmRegistryConfigBase = z110.object({
-  registryType: NpmRegistryType,
-  enabledScopes: z110.array(z110.string()),
-  customRegistryUrl: z110.string().optional(),
-  bypassProxy: z110.boolean().default(false),
-  npmProxyRegistryConfigId: z110.string().optional(),
-  npmProxyVersion: z110.number().optional()
-});
-var NpmRegistryConfig = NpmRegistryConfigBase.and(NpmRegistryAuthConfig);
-var SsoProvider = z111.object({
-  providerId: z111.string(),
-  defaultAutoInviteValue: z111.boolean(),
-  autoInviteDomains: z111.record(z111.string(), z111.boolean()),
-  skipDocsSupernovaLogin: z111.boolean(),
-  areInvitesDisabled: z111.boolean(),
-  isTestMode: z111.boolean(),
-  emailDomains: z111.array(z111.string()),
-  metadataXml: z111.string().nullish()
-});
-var isValidCIDR = (value) => {
-  return IPCIDR.isValidAddress(value);
-};
-var WorkspaceIpWhitelistEntry = z112.object({
-  isEnabled: z112.boolean(),
-  name: z112.string(),
-  range: z112.string().refine(isValidCIDR, {
-    message: "Invalid IP CIDR"
-  })
-});
-var WorkspaceIpSettings = z112.object({
-  isEnabledForCloud: z112.boolean(),
-  isEnabledForDocs: z112.boolean(),
-  entries: z112.array(WorkspaceIpWhitelistEntry)
-});
-var WorkspaceProfile = z112.object({
-  name: z112.string(),
-  handle: z112.string(),
-  color: z112.string(),
-  avatar: nullishToOptional(z112.string()),
-  billingDetails: nullishToOptional(BillingDetails)
-});
-var WorkspaceProfileUpdate = WorkspaceProfile.omit({
-  avatar: true
-});
-var Workspace = z112.object({
-  id: z112.string(),
-  profile: WorkspaceProfile,
-  subscription: Subscription,
-  ipWhitelist: nullishToOptional(WorkspaceIpSettings),
-  sso: nullishToOptional(SsoProvider),
-  npmRegistrySettings: nullishToOptional(NpmRegistryConfig)
-});
-var WorkspaceWithDesignSystems = z112.object({
-  workspace: Workspace,
-  designSystems: z112.array(DesignSystem)
-});
-var DesignSystemSwitcher = z113.object({
-  isEnabled: z113.boolean(),
-  designSystemIds: z113.array(z113.string())
-});
-var DesignSystem = z113.object({
-  id: z113.string(),
-  workspaceId: z113.string(),
-  name: z113.string(),
-  description: z113.string(),
-  docExporterId: nullishToOptional(z113.string()),
-  docSlug: z113.string(),
-  docUserSlug: nullishToOptional(z113.string()),
-  docSlugDeprecated: z113.string(),
-  isPublic: z113.boolean(),
-  isMultibrand: z113.boolean(),
-  docViewUrl: nullishToOptional(z113.string()),
-  basePrefixes: z113.array(z113.string()),
-  designSystemSwitcher: nullishToOptional(DesignSystemSwitcher),
-  createdAt: z113.coerce.date(),
-  updatedAt: z113.coerce.date()
-});
-var DesignSystemWithWorkspace = z113.object({
-  designSystem: DesignSystem,
-  workspace: Workspace
-});
-var DS_NAME_MIN_LENGTH = 2;
-var DS_NAME_MAX_LENGTH = 64;
-var DS_DESC_MAX_LENGTH = 64;
-var DesignSystemUpdateInputMetadata = z114.object({
-  name: z114.string().min(DS_NAME_MIN_LENGTH).max(DS_NAME_MAX_LENGTH).trim().optional(),
-  description: z114.string().max(DS_DESC_MAX_LENGTH).trim().optional()
-});
-var DesignSystemUpdateInput = DesignSystem.partial().omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true,
-  docSlug: true,
-  docViewUrl: true,
-  designSystemSwitcher: true
-}).extend({
-  meta: DesignSystemUpdateInputMetadata.optional()
-});
-var DS_NAME_MIN_LENGTH2 = 2;
-var DS_NAME_MAX_LENGTH2 = 64;
-var DS_DESC_MAX_LENGTH2 = 64;
-var DesignSystemCreateInputMetadata = z115.object({
-  name: z115.string().min(DS_NAME_MIN_LENGTH2).max(DS_NAME_MAX_LENGTH2).trim(),
-  description: z115.string().max(DS_DESC_MAX_LENGTH2).trim()
-});
-var DesignSystemCreateInput = z115.object({
-  meta: DesignSystemCreateInputMetadata,
-  workspaceId: z115.string(),
-  isPublic: z115.boolean().optional(),
-  basePrefixes: z115.array(z115.string()).optional(),
-  docUserSlug: z115.string().nullish().optional(),
-  source: z115.array(z115.string()).optional()
-});
-var ExporterPropertyImageValue = z116.object({
-  asset: PageBlockAsset.optional(),
-  assetId: z116.string().optional(),
-  assetUrl: z116.string().optional()
-});
-var ExporterPropertyValue = z116.object({
-  key: z116.string(),
-  value: z116.union([
-    z116.number(),
-    z116.string(),
-    z116.boolean(),
-    ExporterPropertyImageValue,
-    ColorTokenData,
-    TypographyTokenData
-  ])
-});
-var ExporterPropertyValuesCollection = z116.object({
-  id: z116.string(),
-  designSystemId: z116.string(),
-  exporterId: z116.string(),
-  values: z116.array(ExporterPropertyValue)
-});
-var PublishedDocPage = z117.object({
-  id: z117.string(),
-  publishedDocId: z117.string(),
-  pageShortPersistentId: z117.string(),
-  pathV1: z117.string(),
-  pathV2: z117.string(),
-  storagePath: z117.string(),
-  locale: z117.string().optional(),
-  isPrivate: z117.boolean(),
-  isHidden: z117.boolean(),
-  createdAt: z117.coerce.date(),
-  updatedAt: z117.coerce.date()
-});
-var publishedDocEnvironments = ["Live", "Preview"];
-var PublishedDocEnvironment = z118.enum(publishedDocEnvironments);
-var PublishedDocsChecksums = z118.record(z118.string());
-var PublishedDocRoutingVersion = z118.enum(["1", "2"]);
-var PublishedDoc = z118.object({
-  id: z118.string(),
-  designSystemVersionId: z118.string(),
-  createdAt: z118.coerce.date(),
-  updatedAt: z118.coerce.date(),
-  lastPublishedAt: z118.coerce.date(),
-  isDefault: z118.boolean(),
-  isPublic: z118.boolean(),
-  environment: PublishedDocEnvironment,
-  checksums: PublishedDocsChecksums,
-  storagePath: z118.string(),
-  wasMigrated: z118.boolean(),
-  routingVersion: PublishedDocRoutingVersion,
-  usesLocalizations: z118.boolean(),
-  wasPublishedWithLocalizations: z118.boolean(),
-  tokenCount: z118.number(),
-  assetCount: z118.number()
-});
-var DesignSystemVersion = z119.object({
-  id: z119.string(),
-  version: z119.string(),
-  createdAt: z119.date(),
-  designSystemId: z119.string(),
-  name: z119.string(),
-  comment: z119.string(),
-  isReadonly: z119.boolean(),
-  changeLog: z119.string(),
-  parentId: z119.string().optional(),
-  isDraftsFeatureAdopted: z119.boolean()
-});
-var VersionCreationJobStatus = z119.enum(["Success", "InProgress", "Error"]);
-var VersionCreationJob = z119.object({
-  id: z119.string(),
-  version: z119.string(),
-  designSystemId: z119.string(),
-  designSystemVersionId: nullishToOptional(z119.string()),
-  status: VersionCreationJobStatus,
-  errorMessage: nullishToOptional(z119.string())
-});
-var BITBUCKET_SLUG = /^[-a-zA-Z0-9~]*$/;
-var BITBUCKET_MAX_LENGTH = 64;
-var ExportJobDocumentationChanges = z120.object({
-  pagePersistentIds: z120.string().array(),
-  groupPersistentIds: z120.string().array()
-});
-var ExporterDestinationDocs = z120.object({
-  environment: PublishedDocEnvironment,
-  changes: nullishToOptional(ExportJobDocumentationChanges)
-});
-var ExporterDestinationS3 = z120.object({});
-var ExporterDestinationGithub = z120.object({
-  credentialId: z120.string().optional(),
-  // Repository
-  url: z120.string(),
-  // Location
-  branch: z120.string(),
-  relativePath: nullishToOptional(z120.string()),
-  // Legacy deprecated fields. Use `credentialId` instead
-  connectionId: nullishToOptional(z120.string()),
-  userId: nullishToOptional(z120.number())
-});
-var ExporterDestinationAzure = z120.object({
-  credentialId: z120.string().optional(),
-  // Repository
-  organizationId: z120.string(),
-  projectId: z120.string(),
-  repositoryId: z120.string(),
-  // Location
-  branch: z120.string(),
-  relativePath: nullishToOptional(z120.string()),
-  // Maybe not needed
-  url: nullishToOptional(z120.string()),
-  // Legacy deprecated fields. Use `credentialId` instead
-  connectionId: nullishToOptional(z120.string()),
-  userId: nullishToOptional(z120.number())
-});
-var ExporterDestinationGitlab = z120.object({
-  credentialId: z120.string().optional(),
-  // Repository
-  projectId: z120.string(),
-  // Location
-  branch: z120.string(),
-  relativePath: nullishToOptional(z120.string()),
-  // Maybe not needed
-  url: nullishToOptional(z120.string()),
-  // Legacy deprecated fields. Use `credentialId` instead
-  connectionId: nullishToOptional(z120.string()),
-  userId: nullishToOptional(z120.number())
-});
-var ExporterDestinationBitbucket = z120.object({
-  credentialId: z120.string().optional(),
-  // Repository
-  workspaceSlug: z120.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
-  projectKey: z120.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
-  repoSlug: z120.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
-  // Location
-  branch: z120.string(),
-  relativePath: nullishToOptional(z120.string()),
-  // Legacy deprecated fields. Use `credentialId` instead
-  connectionId: nullishToOptional(z120.string()),
-  userId: nullishToOptional(z120.number())
-});
-var ExportDestinationsMap = z120.object({
-  webhookUrl: z120.string().optional(),
-  destinationSnDocs: ExporterDestinationDocs.optional(),
-  destinationS3: ExporterDestinationS3.optional(),
-  destinationGithub: ExporterDestinationGithub.optional(),
-  destinationAzure: ExporterDestinationAzure.optional(),
-  destinationGitlab: ExporterDestinationGitlab.optional(),
-  destinationBitbucket: ExporterDestinationBitbucket.optional()
-});
-var PipelineEventType = z121.enum(["OnVersionReleased", "OnHeadChanged", "OnSourceUpdated", "None"]);
-var PipelineDestinationGitType = z121.enum(["Github", "Gitlab", "Bitbucket", "Azure"]);
-var PipelineDestinationExtraType = z121.enum(["WebhookUrl", "S3", "Documentation"]);
-var PipelineDestinationType = z121.union([PipelineDestinationGitType, PipelineDestinationExtraType]);
-var Pipeline = z121.object({
-  id: z121.string(),
-  name: z121.string(),
-  eventType: PipelineEventType,
-  isEnabled: z121.boolean(),
-  workspaceId: z121.string(),
-  designSystemId: z121.string(),
-  exporterId: z121.string(),
-  brandPersistentId: z121.string().optional(),
-  themePersistentId: z121.string().optional(),
-  // Destinations
-  ...ExportDestinationsMap.shape
-});
-var ExportJobDump = z122.object({
-  id: z122.string(),
-  createdAt: z122.coerce.date(),
-  finishedAt: z122.coerce.date(),
-  exportArtefacts: z122.string()
-});
-var CodeIntegrationDump = z122.object({
-  exporters: Exporter.array(),
-  pipelines: Pipeline.array(),
-  exportJobs: ExportJobDump.array()
-});
-var DesignSystemVersionRoom = Entity.extend({
-  designSystemVersionId: z123.string(),
-  liveblocksId: z123.string()
-});
-var DesignSystemVersionRoomInternalSettings = z123.object({
-  routingVersion: z123.string(),
-  isDraftFeatureAdopted: z123.boolean()
-});
-var DesignSystemVersionRoomInitialState = z123.object({
-  pages: z123.array(DocumentationPageV2),
-  groups: z123.array(ElementGroup),
-  pageSnapshots: z123.array(DocumentationPageSnapshot),
-  groupSnapshots: z123.array(ElementGroupSnapshot),
-  internalSettings: DesignSystemVersionRoomInternalSettings
-});
-var DesignSystemVersionRoomUpdate = z123.object({
-  pages: z123.array(DocumentationPageV2),
-  groups: z123.array(ElementGroup),
-  pageIdsToDelete: z123.array(z123.string()),
-  groupIdsToDelete: z123.array(z123.string()),
-  pageSnapshots: z123.array(DocumentationPageSnapshot),
-  groupSnapshots: z123.array(ElementGroupSnapshot),
-  pageSnapshotIdsToDelete: z123.array(z123.string()),
-  groupSnapshotIdsToDelete: z123.array(z123.string()),
-  pageHashesToUpdate: z123.record(z123.string(), z123.string())
-});
-var DocumentationPageRoom = Entity.extend({
-  designSystemVersionId: z124.string(),
-  documentationPageId: z124.string(),
-  liveblocksId: z124.string(),
-  isDirty: z124.boolean()
-});
-var DocumentationPageRoomState = z124.object({
-  pageItems: z124.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
-  itemConfiguration: DocumentationItemConfigurationV2
-});
-var DocumentationPageRoomRoomUpdate = z124.object({
-  page: DocumentationPageV2,
-  pageParent: ElementGroup
-});
-var DocumentationPageRoomInitialStateUpdate = DocumentationPageRoomRoomUpdate.extend({
-  pageItems: z124.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
-  blockDefinitions: z124.array(PageBlockDefinition)
-});
-var RestoredDocumentationPage = z124.object({
-  page: DocumentationPageV2,
-  pageParent: ElementGroup,
-  pageContent: DocumentationPageContentData,
-  contentHash: z124.string(),
-  roomId: z124.string().optional()
-});
-var RestoredDocumentationGroup = z124.object({
-  group: ElementGroup,
-  parent: ElementGroup
-});
-var RoomTypeEnum = /* @__PURE__ */ ((RoomTypeEnum2) => {
-  RoomTypeEnum2["DocumentationPage"] = "documentation-page";
-  RoomTypeEnum2["DesignSystemVersion"] = "design-system-version";
-  RoomTypeEnum2["Workspace"] = "workspace";
-  return RoomTypeEnum2;
-})(RoomTypeEnum || {});
-var RoomTypeSchema = z125.nativeEnum(RoomTypeEnum);
-var RoomType = RoomTypeSchema.enum;
-var WorkspaceRoom = Entity.extend({
-  workspaceId: z126.string(),
-  liveblocksId: z126.string()
-});
-var PublishedDocsDump = z127.object({
-  documentation: PublishedDoc,
-  pages: PublishedDocPage.array()
-});
-var DocumentationThreadDump = z128.object({
-  thread: DocumentationCommentThread,
-  comments: DocumentationComment.array()
-});
-var DocumentationPageRoomDump = z128.object({
-  room: DocumentationPageRoom,
-  threads: DocumentationThreadDump.array()
-});
-var DesignSystemVersionMultiplayerDump = z128.object({
-  documentationPages: DocumentationPageRoomDump.array()
-});
-var DesignSystemVersionDump = z128.object({
-  version: DesignSystemVersion,
-  brands: Brand.array(),
-  elements: DesignElement.array(),
-  elementPropertyDefinitions: ElementPropertyDefinition.array(),
-  elementPropertyValues: ElementPropertyValue.array(),
-  elementViews: ElementView.array(),
-  elementColumns: ElementViewColumn.array(),
-  documentationPageContents: DocumentationPageContent.array(),
-  documentationPageRooms: DocumentationPageRoomDump.array(),
-  publishedDocumentations: PublishedDocsDump.array(),
-  assetReferences: AssetReference.array()
-});
-var DesignSystemDump = z129.object({
-  designSystem: DesignSystem,
-  dataSources: DataSource.array(),
-  versions: DesignSystemVersionDump.array(),
-  customDomain: CustomDomain.optional(),
-  files: Asset.array()
-});
-var IntegrationAuthType = z130.union([z130.literal("OAuth2"), z130.literal("PAT")]);
-var ExternalServiceType = z130.union([
-  z130.literal("figma"),
-  z130.literal("github"),
-  z130.literal("azure"),
-  z130.literal("gitlab"),
-  z130.literal("bitbucket")
-]);
-var IntegrationUserInfo = z130.object({
-  id: z130.string(),
-  handle: z130.string().optional(),
-  avatarUrl: z130.string().optional(),
-  email: z130.string().optional(),
-  authType: IntegrationAuthType.optional(),
-  customUrl: z130.string().optional()
-});
-var UserLinkedIntegrations = z130.object({
-  figma: IntegrationUserInfo.optional(),
-  github: IntegrationUserInfo.array().optional(),
-  azure: IntegrationUserInfo.array().optional(),
-  gitlab: IntegrationUserInfo.array().optional(),
-  bitbucket: IntegrationUserInfo.array().optional()
-});
-var UserAnalyticsCleanupSchedule = z131.object({
-  userId: z131.string(),
-  createdAt: z131.coerce.date(),
-  deleteAt: z131.coerce.date()
-});
-var UserAnalyticsCleanupScheduleDbInput = UserAnalyticsCleanupSchedule.omit({
-  createdAt: true
-});
-var CreateUserInput = z132.object({
-  email: z132.string(),
-  name: z132.string(),
-  username: z132.string()
-});
-var UserIdentity = z133.object({
-  id: z133.string(),
-  userId: z133.string()
-});
-var UserMinified = z134.object({
-  id: z134.string(),
-  name: z134.string(),
-  email: z134.string(),
-  avatar: z134.string().optional()
-});
-var LiveblocksNotificationSettings = z135.object({
-  sendCommentNotificationEmails: z135.boolean()
-});
-var UserNotificationSettings = z135.object({
-  liveblocksNotificationSettings: LiveblocksNotificationSettings
-});
-var UserOnboardingDepartment = z136.enum(["Design", "Engineering", "Product", "Brand", "Other"]);
-var UserOnboardingJobLevel = z136.enum(["Executive", "Manager", "IndividualContributor", "Other"]);
-var UserOnboarding = z136.object({
-  companyName: z136.string().optional(),
-  numberOfPeopleInOrg: z136.string().optional(),
-  numberOfPeopleInDesignTeam: z136.string().optional(),
-  department: UserOnboardingDepartment.optional(),
-  jobTitle: z136.string().optional(),
-  phase: z136.string().optional(),
-  jobLevel: UserOnboardingJobLevel.optional(),
-  designSystemName: z136.string().optional(),
-  defaultDestination: z136.string().optional(),
-  figmaUrl: z136.string().optional()
-});
-var UserProfile = z136.object({
-  name: z136.string(),
-  avatar: z136.string().optional(),
-  nickname: z136.string().optional(),
-  onboarding: UserOnboarding.optional()
-});
-var UserProfileUpdate = UserProfile.partial().omit({
-  avatar: true
-});
-var UserTest = z137.object({
-  id: z137.string(),
-  email: z137.string()
-});
-var User = z138.object({
-  id: z138.string(),
-  email: z138.string(),
-  emailVerified: z138.boolean(),
-  createdAt: z138.coerce.date(),
-  trialExpiresAt: z138.coerce.date().optional(),
-  profile: UserProfile,
-  linkedIntegrations: UserLinkedIntegrations.optional(),
-  loggedOutAt: z138.coerce.date().optional(),
-  isProtected: z138.boolean()
-});
 var SupernovaException = class _SupernovaException extends Error {
   //
   // Properties
@@ -3154,25 +2582,25 @@ function groupBy(items, keyFn) {
   }
   return result;
 }
-var ContentLoadInstruction = z139.object({
-  from: z139.string(),
-  to: z139.string(),
-  authorizationHeaderKvsId: z139.string().optional(),
-  timeout: z139.number().optional()
+var ContentLoadInstruction = z105.object({
+  from: z105.string(),
+  to: z105.string(),
+  authorizationHeaderKvsId: z105.string().optional(),
+  timeout: z105.number().optional()
 });
-var ContentLoaderPayload = z139.object({
-  type: z139.literal("Single"),
+var ContentLoaderPayload = z105.object({
+  type: z105.literal("Single"),
   instruction: ContentLoadInstruction
 }).or(
-  z139.object({
-    type: z139.literal("Multiple"),
-    loadingChunkSize: z139.number().optional(),
-    instructions: z139.array(ContentLoadInstruction)
+  z105.object({
+    type: z105.literal("Multiple"),
+    loadingChunkSize: z105.number().optional(),
+    instructions: z105.array(ContentLoadInstruction)
   })
 ).or(
-  z139.object({
-    type: z139.literal("S3"),
-    location: z139.string()
+  z105.object({
+    type: z105.literal("S3"),
+    location: z105.string()
   })
 );
 function slugify(str, options) {
@@ -3800,6 +3228,591 @@ var RESERVED_SLUGS = [
 ];
 var RESERVED_SLUGS_SET = new Set(RESERVED_SLUGS);
 var slugRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+var DesignElementSnapshotReason = z106.enum(["Publish", "Deletion"]);
+var DesignElementSnapshotBase = z106.object({
+  id: z106.string(),
+  persistentId: z106.string(),
+  designSystemVersionId: z106.string(),
+  createdAt: z106.coerce.date(),
+  updatedAt: z106.coerce.date(),
+  reason: DesignElementSnapshotReason,
+  createdByUserId: z106.string()
+});
+function pickLatestSnapshots(snapshots, getSnapshotElementId) {
+  const groupedSnapshots = groupBy(snapshots, getSnapshotElementId);
+  return Array.from(groupedSnapshots.entries()).map(([_, snapshots2]) => {
+    const sorted = snapshots2.sort((lhs, rhs) => rhs.createdAt.getTime() - lhs.createdAt.getTime());
+    return sorted[0];
+  });
+}
+var DocumentationPageSnapshot = DesignElementSnapshotBase.extend({
+  page: DocumentationPageV2,
+  pageContentHash: z107.string(),
+  pageContentStorageKey: z107.string()
+});
+function pickLatestPageSnapshots(snapshots) {
+  return pickLatestSnapshots(snapshots, (s) => s.page.id);
+}
+var ElementGroupSnapshot = DesignElementSnapshotBase.extend({
+  group: ElementGroup
+});
+function pickLatestGroupSnapshots(snapshots) {
+  return pickLatestSnapshots(snapshots, (s) => s.group.id);
+}
+var ElementViewBaseColumnType = z108.enum(["Name", "Description", "Value", "UpdatedAt"]);
+var ElementViewColumnType = z108.union([
+  z108.literal("BaseProperty"),
+  z108.literal("PropertyDefinition"),
+  z108.literal("Theme")
+]);
+var ElementViewColumnSharedAttributes = z108.object({
+  id: z108.string(),
+  persistentId: z108.string(),
+  elementDataViewId: z108.string(),
+  sortPosition: z108.number(),
+  width: z108.number()
+});
+var ElementViewBasePropertyColumn = ElementViewColumnSharedAttributes.extend({
+  type: z108.literal("BaseProperty"),
+  basePropertyType: ElementViewBaseColumnType
+});
+var ElementViewPropertyDefinitionColumn = ElementViewColumnSharedAttributes.extend({
+  type: z108.literal("PropertyDefinition"),
+  propertyDefinitionId: z108.string()
+});
+var ElementViewThemeColumn = ElementViewColumnSharedAttributes.extend({
+  type: z108.literal("Theme"),
+  themeId: z108.string()
+});
+var ElementViewColumn = z108.discriminatedUnion("type", [
+  ElementViewBasePropertyColumn,
+  ElementViewPropertyDefinitionColumn,
+  ElementViewThemeColumn
+]);
+var ElementView = z109.object({
+  id: z109.string(),
+  persistentId: z109.string(),
+  designSystemVersionId: z109.string(),
+  name: z109.string(),
+  description: z109.string(),
+  targetElementType: ElementPropertyTargetType,
+  isDefault: z109.boolean()
+});
+var Brand = z110.object({
+  id: z110.string(),
+  designSystemVersionId: z110.string(),
+  persistentId: z110.string(),
+  name: z110.string(),
+  description: z110.string()
+});
+var NpmRegistryAuthType = z111.enum(["Basic", "Bearer", "None", "Custom"]);
+var NpmRegistryType = z111.enum(["NPMJS", "GitHub", "AzureDevOps", "Artifactory", "Custom"]);
+var NpmRegistryBasicAuthConfig = z111.object({
+  authType: z111.literal(NpmRegistryAuthType.Enum.Basic),
+  username: z111.string(),
+  password: z111.string()
+});
+var NpmRegistryBearerAuthConfig = z111.object({
+  authType: z111.literal(NpmRegistryAuthType.Enum.Bearer),
+  accessToken: z111.string()
+});
+var NpmRegistryNoAuthConfig = z111.object({
+  authType: z111.literal(NpmRegistryAuthType.Enum.None)
+});
+var NpmRegistrCustomAuthConfig = z111.object({
+  authType: z111.literal(NpmRegistryAuthType.Enum.Custom),
+  authHeaderName: z111.string(),
+  authHeaderValue: z111.string()
+});
+var NpmRegistryAuthConfig = z111.discriminatedUnion("authType", [
+  NpmRegistryBasicAuthConfig,
+  NpmRegistryBearerAuthConfig,
+  NpmRegistryNoAuthConfig,
+  NpmRegistrCustomAuthConfig
+]);
+var NpmRegistryConfigBase = z111.object({
+  registryType: NpmRegistryType,
+  enabledScopes: z111.array(z111.string()),
+  customRegistryUrl: z111.string().optional(),
+  bypassProxy: z111.boolean().default(false),
+  npmProxyRegistryConfigId: z111.string().optional(),
+  npmProxyVersion: z111.number().optional()
+});
+var NpmRegistryConfig = NpmRegistryConfigBase.and(NpmRegistryAuthConfig);
+var SsoProvider = z112.object({
+  providerId: z112.string(),
+  defaultAutoInviteValue: z112.boolean(),
+  autoInviteDomains: z112.record(z112.string(), z112.boolean()),
+  skipDocsSupernovaLogin: z112.boolean(),
+  areInvitesDisabled: z112.boolean(),
+  isTestMode: z112.boolean(),
+  emailDomains: z112.array(z112.string()),
+  metadataXml: z112.string().nullish()
+});
+var isValidCIDR = (value) => {
+  return IPCIDR.isValidAddress(value);
+};
+var WorkspaceIpWhitelistEntry = z113.object({
+  isEnabled: z113.boolean(),
+  name: z113.string(),
+  range: z113.string().refine(isValidCIDR, {
+    message: "Invalid IP CIDR"
+  })
+});
+var WorkspaceIpSettings = z113.object({
+  isEnabledForCloud: z113.boolean(),
+  isEnabledForDocs: z113.boolean(),
+  entries: z113.array(WorkspaceIpWhitelistEntry)
+});
+var WorkspaceProfile = z113.object({
+  name: z113.string(),
+  handle: z113.string(),
+  color: z113.string(),
+  avatar: nullishToOptional(z113.string()),
+  billingDetails: nullishToOptional(BillingDetails)
+});
+var WorkspaceProfileUpdate = WorkspaceProfile.omit({
+  avatar: true
+});
+var Workspace = z113.object({
+  id: z113.string(),
+  profile: WorkspaceProfile,
+  subscription: Subscription,
+  ipWhitelist: nullishToOptional(WorkspaceIpSettings),
+  sso: nullishToOptional(SsoProvider),
+  npmRegistrySettings: nullishToOptional(NpmRegistryConfig)
+});
+var WorkspaceWithDesignSystems = z113.object({
+  workspace: Workspace,
+  designSystems: z113.array(DesignSystem)
+});
+var DesignSystemSwitcher = z114.object({
+  isEnabled: z114.boolean(),
+  designSystemIds: z114.array(z114.string())
+});
+var DesignSystem = z114.object({
+  id: z114.string(),
+  workspaceId: z114.string(),
+  name: z114.string(),
+  description: z114.string(),
+  docExporterId: nullishToOptional(z114.string()),
+  docSlug: z114.string(),
+  docUserSlug: nullishToOptional(z114.string()),
+  docSlugDeprecated: z114.string(),
+  isPublic: z114.boolean(),
+  isMultibrand: z114.boolean(),
+  docViewUrl: nullishToOptional(z114.string()),
+  basePrefixes: z114.array(z114.string()),
+  designSystemSwitcher: nullishToOptional(DesignSystemSwitcher),
+  createdAt: z114.coerce.date(),
+  updatedAt: z114.coerce.date()
+});
+var DesignSystemWithWorkspace = z114.object({
+  designSystem: DesignSystem,
+  workspace: Workspace
+});
+var DS_NAME_MIN_LENGTH = 2;
+var DS_NAME_MAX_LENGTH = 64;
+var DS_DESC_MAX_LENGTH = 64;
+var DesignSystemUpdateInputMetadata = z115.object({
+  name: z115.string().min(DS_NAME_MIN_LENGTH).max(DS_NAME_MAX_LENGTH).trim().optional(),
+  description: z115.string().max(DS_DESC_MAX_LENGTH).trim().optional()
+});
+var DesignSystemUpdateInput = DesignSystem.partial().omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+  docSlug: true,
+  docViewUrl: true,
+  designSystemSwitcher: true
+}).extend({
+  meta: DesignSystemUpdateInputMetadata.optional()
+});
+var DS_NAME_MIN_LENGTH2 = 2;
+var DS_NAME_MAX_LENGTH2 = 64;
+var DS_DESC_MAX_LENGTH2 = 64;
+var DesignSystemCreateInputMetadata = z116.object({
+  name: z116.string().min(DS_NAME_MIN_LENGTH2).max(DS_NAME_MAX_LENGTH2).trim(),
+  description: z116.string().max(DS_DESC_MAX_LENGTH2).trim()
+});
+var DesignSystemCreateInput = z116.object({
+  meta: DesignSystemCreateInputMetadata,
+  workspaceId: z116.string(),
+  isPublic: z116.boolean().optional(),
+  basePrefixes: z116.array(z116.string()).optional(),
+  docUserSlug: z116.string().nullish().optional(),
+  source: z116.array(z116.string()).optional()
+});
+var ExporterPropertyImageValue = z117.object({
+  asset: PageBlockAsset.optional(),
+  assetId: z117.string().optional(),
+  assetUrl: z117.string().optional()
+});
+var ExporterPropertyValue = z117.object({
+  key: z117.string(),
+  value: z117.union([
+    z117.number(),
+    z117.string(),
+    z117.boolean(),
+    ExporterPropertyImageValue,
+    ColorTokenData,
+    TypographyTokenData
+  ])
+});
+var ExporterPropertyValuesCollection = z117.object({
+  id: z117.string(),
+  designSystemId: z117.string(),
+  exporterId: z117.string(),
+  values: z117.array(ExporterPropertyValue)
+});
+var PublishedDocPage = z118.object({
+  id: z118.string(),
+  publishedDocId: z118.string(),
+  pageShortPersistentId: z118.string(),
+  pathV1: z118.string(),
+  pathV2: z118.string(),
+  storagePath: z118.string(),
+  locale: z118.string().optional(),
+  isPrivate: z118.boolean(),
+  isHidden: z118.boolean(),
+  createdAt: z118.coerce.date(),
+  updatedAt: z118.coerce.date()
+});
+var publishedDocEnvironments = ["Live", "Preview"];
+var PublishedDocEnvironment = z119.enum(publishedDocEnvironments);
+var PublishedDocsChecksums = z119.record(z119.string());
+var PublishedDocRoutingVersion = z119.enum(["1", "2"]);
+var PublishedDoc = z119.object({
+  id: z119.string(),
+  designSystemVersionId: z119.string(),
+  createdAt: z119.coerce.date(),
+  updatedAt: z119.coerce.date(),
+  lastPublishedAt: z119.coerce.date(),
+  isDefault: z119.boolean(),
+  isPublic: z119.boolean(),
+  environment: PublishedDocEnvironment,
+  checksums: PublishedDocsChecksums,
+  storagePath: z119.string(),
+  wasMigrated: z119.boolean(),
+  routingVersion: PublishedDocRoutingVersion,
+  usesLocalizations: z119.boolean(),
+  wasPublishedWithLocalizations: z119.boolean(),
+  tokenCount: z119.number(),
+  assetCount: z119.number()
+});
+var DesignSystemVersion = z120.object({
+  id: z120.string(),
+  version: z120.string(),
+  createdAt: z120.date(),
+  designSystemId: z120.string(),
+  name: z120.string(),
+  comment: z120.string(),
+  isReadonly: z120.boolean(),
+  changeLog: z120.string(),
+  parentId: z120.string().optional(),
+  isDraftsFeatureAdopted: z120.boolean()
+});
+var VersionCreationJobStatus = z120.enum(["Success", "InProgress", "Error"]);
+var VersionCreationJob = z120.object({
+  id: z120.string(),
+  version: z120.string(),
+  designSystemId: z120.string(),
+  designSystemVersionId: nullishToOptional(z120.string()),
+  status: VersionCreationJobStatus,
+  errorMessage: nullishToOptional(z120.string())
+});
+var BITBUCKET_SLUG = /^[-a-zA-Z0-9~]*$/;
+var BITBUCKET_MAX_LENGTH = 64;
+var ExportJobDocumentationChanges = z121.object({
+  pagePersistentIds: z121.string().array(),
+  groupPersistentIds: z121.string().array()
+});
+var ExporterDestinationDocs = z121.object({
+  environment: PublishedDocEnvironment,
+  changes: nullishToOptional(ExportJobDocumentationChanges)
+});
+var ExporterDestinationS3 = z121.object({});
+var ExporterDestinationGithub = z121.object({
+  credentialId: z121.string().optional(),
+  // Repository
+  url: z121.string(),
+  // Location
+  branch: z121.string(),
+  relativePath: nullishToOptional(z121.string()),
+  // Legacy deprecated fields. Use `credentialId` instead
+  connectionId: nullishToOptional(z121.string()),
+  userId: nullishToOptional(z121.number())
+});
+var ExporterDestinationAzure = z121.object({
+  credentialId: z121.string().optional(),
+  // Repository
+  organizationId: z121.string(),
+  projectId: z121.string(),
+  repositoryId: z121.string(),
+  // Location
+  branch: z121.string(),
+  relativePath: nullishToOptional(z121.string()),
+  // Maybe not needed
+  url: nullishToOptional(z121.string()),
+  // Legacy deprecated fields. Use `credentialId` instead
+  connectionId: nullishToOptional(z121.string()),
+  userId: nullishToOptional(z121.number())
+});
+var ExporterDestinationGitlab = z121.object({
+  credentialId: z121.string().optional(),
+  // Repository
+  projectId: z121.string(),
+  // Location
+  branch: z121.string(),
+  relativePath: nullishToOptional(z121.string()),
+  // Maybe not needed
+  url: nullishToOptional(z121.string()),
+  // Legacy deprecated fields. Use `credentialId` instead
+  connectionId: nullishToOptional(z121.string()),
+  userId: nullishToOptional(z121.number())
+});
+var ExporterDestinationBitbucket = z121.object({
+  credentialId: z121.string().optional(),
+  // Repository
+  workspaceSlug: z121.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
+  projectKey: z121.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
+  repoSlug: z121.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
+  // Location
+  branch: z121.string(),
+  relativePath: nullishToOptional(z121.string()),
+  // Legacy deprecated fields. Use `credentialId` instead
+  connectionId: nullishToOptional(z121.string()),
+  userId: nullishToOptional(z121.number())
+});
+var ExportDestinationsMap = z121.object({
+  webhookUrl: z121.string().optional(),
+  destinationSnDocs: ExporterDestinationDocs.optional(),
+  destinationS3: ExporterDestinationS3.optional(),
+  destinationGithub: ExporterDestinationGithub.optional(),
+  destinationAzure: ExporterDestinationAzure.optional(),
+  destinationGitlab: ExporterDestinationGitlab.optional(),
+  destinationBitbucket: ExporterDestinationBitbucket.optional()
+});
+var PipelineEventType = z122.enum(["OnVersionReleased", "OnHeadChanged", "OnSourceUpdated", "None"]);
+var PipelineDestinationGitType = z122.enum(["Github", "Gitlab", "Bitbucket", "Azure"]);
+var PipelineDestinationExtraType = z122.enum(["WebhookUrl", "S3", "Documentation"]);
+var PipelineDestinationType = z122.union([PipelineDestinationGitType, PipelineDestinationExtraType]);
+var Pipeline = z122.object({
+  id: z122.string(),
+  name: z122.string(),
+  eventType: PipelineEventType,
+  isEnabled: z122.boolean(),
+  workspaceId: z122.string(),
+  designSystemId: z122.string(),
+  exporterId: z122.string(),
+  brandPersistentId: z122.string().optional(),
+  themePersistentId: z122.string().optional(),
+  // Destinations
+  ...ExportDestinationsMap.shape
+});
+var ExportJobDump = z123.object({
+  id: z123.string(),
+  createdAt: z123.coerce.date(),
+  finishedAt: z123.coerce.date(),
+  exportArtefacts: z123.string()
+});
+var CodeIntegrationDump = z123.object({
+  exporters: Exporter.array(),
+  pipelines: Pipeline.array(),
+  exportJobs: ExportJobDump.array()
+});
+var DesignSystemVersionRoom = Entity.extend({
+  designSystemVersionId: z124.string(),
+  liveblocksId: z124.string()
+});
+var DesignSystemVersionRoomInternalSettings = z124.object({
+  routingVersion: z124.string(),
+  isDraftFeatureAdopted: z124.boolean()
+});
+var DesignSystemVersionRoomInitialState = z124.object({
+  pages: z124.array(DocumentationPageV2),
+  groups: z124.array(ElementGroup),
+  pageSnapshots: z124.array(DocumentationPageSnapshot),
+  groupSnapshots: z124.array(ElementGroupSnapshot),
+  internalSettings: DesignSystemVersionRoomInternalSettings
+});
+var DesignSystemVersionRoomUpdate = z124.object({
+  pages: z124.array(DocumentationPageV2),
+  groups: z124.array(ElementGroup),
+  pageIdsToDelete: z124.array(z124.string()),
+  groupIdsToDelete: z124.array(z124.string()),
+  pageSnapshots: z124.array(DocumentationPageSnapshot),
+  groupSnapshots: z124.array(ElementGroupSnapshot),
+  pageSnapshotIdsToDelete: z124.array(z124.string()),
+  groupSnapshotIdsToDelete: z124.array(z124.string()),
+  pageHashesToUpdate: z124.record(z124.string(), z124.string())
+});
+var DocumentationPageRoom = Entity.extend({
+  designSystemVersionId: z125.string(),
+  documentationPageId: z125.string(),
+  liveblocksId: z125.string(),
+  isDirty: z125.boolean()
+});
+var DocumentationPageRoomState = z125.object({
+  pageItems: z125.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
+  itemConfiguration: DocumentationItemConfigurationV2
+});
+var DocumentationPageRoomRoomUpdate = z125.object({
+  page: DocumentationPageV2,
+  pageParent: ElementGroup
+});
+var DocumentationPageRoomInitialStateUpdate = DocumentationPageRoomRoomUpdate.extend({
+  pageItems: z125.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
+  blockDefinitions: z125.array(PageBlockDefinition)
+});
+var RestoredDocumentationPage = z125.object({
+  page: DocumentationPageV2,
+  pageParent: ElementGroup,
+  pageContent: DocumentationPageContentData,
+  contentHash: z125.string(),
+  roomId: z125.string().optional()
+});
+var RestoredDocumentationGroup = z125.object({
+  group: ElementGroup,
+  parent: ElementGroup
+});
+var RoomTypeEnum = /* @__PURE__ */ ((RoomTypeEnum2) => {
+  RoomTypeEnum2["DocumentationPage"] = "documentation-page";
+  RoomTypeEnum2["DesignSystemVersion"] = "design-system-version";
+  RoomTypeEnum2["Workspace"] = "workspace";
+  return RoomTypeEnum2;
+})(RoomTypeEnum || {});
+var RoomTypeSchema = z126.nativeEnum(RoomTypeEnum);
+var RoomType = RoomTypeSchema.enum;
+var WorkspaceRoom = Entity.extend({
+  workspaceId: z127.string(),
+  liveblocksId: z127.string()
+});
+var PublishedDocsDump = z128.object({
+  documentation: PublishedDoc,
+  pages: PublishedDocPage.array()
+});
+var DocumentationThreadDump = z129.object({
+  thread: DocumentationCommentThread,
+  comments: DocumentationComment.array()
+});
+var DocumentationPageRoomDump = z129.object({
+  room: DocumentationPageRoom,
+  threads: DocumentationThreadDump.array()
+});
+var DesignSystemVersionMultiplayerDump = z129.object({
+  documentationPages: DocumentationPageRoomDump.array()
+});
+var DesignSystemVersionDump = z129.object({
+  version: DesignSystemVersion,
+  brands: Brand.array(),
+  elements: DesignElement.array(),
+  elementPropertyDefinitions: ElementPropertyDefinition.array(),
+  elementPropertyValues: ElementPropertyValue.array(),
+  elementViews: ElementView.array(),
+  elementColumns: ElementViewColumn.array(),
+  documentationPageContents: DocumentationPageContent.array(),
+  documentationPageRooms: DocumentationPageRoomDump.array(),
+  publishedDocumentations: PublishedDocsDump.array(),
+  assetReferences: AssetReference.array()
+});
+var DesignSystemDump = z130.object({
+  designSystem: DesignSystem,
+  dataSources: DataSource.array(),
+  versions: DesignSystemVersionDump.array(),
+  customDomain: CustomDomain.optional(),
+  files: Asset.array()
+});
+var IntegrationAuthType = z131.union([z131.literal("OAuth2"), z131.literal("PAT")]);
+var ExternalServiceType = z131.union([
+  z131.literal("figma"),
+  z131.literal("github"),
+  z131.literal("azure"),
+  z131.literal("gitlab"),
+  z131.literal("bitbucket")
+]);
+var IntegrationUserInfo = z131.object({
+  id: z131.string(),
+  handle: z131.string().optional(),
+  avatarUrl: z131.string().optional(),
+  email: z131.string().optional(),
+  authType: IntegrationAuthType.optional(),
+  customUrl: z131.string().optional()
+});
+var UserLinkedIntegrations = z131.object({
+  figma: IntegrationUserInfo.optional(),
+  github: IntegrationUserInfo.array().optional(),
+  azure: IntegrationUserInfo.array().optional(),
+  gitlab: IntegrationUserInfo.array().optional(),
+  bitbucket: IntegrationUserInfo.array().optional()
+});
+var UserAnalyticsCleanupSchedule = z132.object({
+  userId: z132.string(),
+  createdAt: z132.coerce.date(),
+  deleteAt: z132.coerce.date()
+});
+var UserAnalyticsCleanupScheduleDbInput = UserAnalyticsCleanupSchedule.omit({
+  createdAt: true
+});
+var CreateUserInput = z133.object({
+  email: z133.string(),
+  name: z133.string(),
+  username: z133.string()
+});
+var UserIdentity = z134.object({
+  id: z134.string(),
+  userId: z134.string()
+});
+var UserMinified = z135.object({
+  id: z135.string(),
+  name: z135.string(),
+  email: z135.string(),
+  avatar: z135.string().optional()
+});
+var LiveblocksNotificationSettings = z136.object({
+  sendCommentNotificationEmails: z136.boolean()
+});
+var UserNotificationSettings = z136.object({
+  liveblocksNotificationSettings: LiveblocksNotificationSettings
+});
+var UserOnboardingDepartment = z137.enum(["Design", "Engineering", "Product", "Brand", "Other"]);
+var UserOnboardingJobLevel = z137.enum(["Executive", "Manager", "IndividualContributor", "Other"]);
+var UserOnboarding = z137.object({
+  companyName: z137.string().optional(),
+  numberOfPeopleInOrg: z137.string().optional(),
+  numberOfPeopleInDesignTeam: z137.string().optional(),
+  department: UserOnboardingDepartment.optional(),
+  jobTitle: z137.string().optional(),
+  phase: z137.string().optional(),
+  jobLevel: UserOnboardingJobLevel.optional(),
+  designSystemName: z137.string().optional(),
+  defaultDestination: z137.string().optional(),
+  figmaUrl: z137.string().optional()
+});
+var UserProfile = z137.object({
+  name: z137.string(),
+  avatar: z137.string().optional(),
+  nickname: z137.string().optional(),
+  onboarding: UserOnboarding.optional()
+});
+var UserProfileUpdate = UserProfile.partial().omit({
+  avatar: true
+});
+var UserTest = z138.object({
+  id: z138.string(),
+  email: z138.string()
+});
+var User = z139.object({
+  id: z139.string(),
+  email: z139.string(),
+  emailVerified: z139.boolean(),
+  createdAt: z139.coerce.date(),
+  trialExpiresAt: z139.coerce.date().optional(),
+  profile: UserProfile,
+  linkedIntegrations: UserLinkedIntegrations.optional(),
+  loggedOutAt: z139.coerce.date().optional(),
+  isProtected: z139.boolean()
+});
 var IntegrationDesignSystem = z140.object({
   designSystemId: z140.string(),
   brandId: z140.string(),
@@ -5040,10 +5053,10 @@ var DTOGetDocumentationPageAnchorsResponse = z181.object({
 var DTOPageBlockItemV2 = PageBlockItemV2;
 
 // src/api/dto/documentation/documentation-page-snapshot.ts
-import { z as z185 } from "zod";
+import { z as z186 } from "zod";
 
 // src/api/dto/elements/documentation/page-v2.ts
-import { z as z184 } from "zod";
+import { z as z185 } from "zod";
 
 // src/api/dto/elements/documentation/draft-state.ts
 import { z as z183 } from "zod";
@@ -5072,7 +5085,9 @@ var DTODocumentationDraftStateUpdated = z183.object({
   })
 });
 var DTODocumentationDraftStateDeleted = z183.object({
-  changeType: z183.literal(DTODocumentationDraftChangeType.enum.Deleted)
+  changeType: z183.literal(DTODocumentationDraftChangeType.enum.Deleted),
+  deletedAt: z183.coerce.date(),
+  deletedByUserId: z183.string()
 });
 var DTODocumentationDraftState = z183.discriminatedUnion("changeType", [
   DTODocumentationDraftStateCreated,
@@ -5080,199 +5095,208 @@ var DTODocumentationDraftState = z183.discriminatedUnion("changeType", [
   DTODocumentationDraftStateDeleted
 ]);
 
+// src/api/dto/elements/documentation/metadata.ts
+import { z as z184 } from "zod";
+var DTODocumentationPublishMetadata = z184.object({
+  lastPublishedByUserId: z184.string(),
+  lastPublishedAt: z184.coerce.date()
+});
+
 // src/api/dto/elements/documentation/page-v2.ts
-var DTODocumentationPageV2 = z184.object({
-  id: z184.string(),
-  persistentId: z184.string(),
-  designSystemVersionId: z184.string(),
-  title: z184.string(),
+var DTODocumentationPageV2 = z185.object({
+  id: z185.string(),
+  persistentId: z185.string(),
+  designSystemVersionId: z185.string(),
+  title: z185.string(),
   configuration: DTODocumentationItemConfigurationV2,
-  shortPersistentId: z184.string(),
-  slug: z184.string().optional(),
-  userSlug: z184.string().optional(),
-  createdAt: z184.coerce.date(),
-  updatedAt: z184.coerce.date(),
-  path: z184.string(),
+  shortPersistentId: z185.string(),
+  slug: z185.string().optional(),
+  userSlug: z185.string().optional(),
+  createdAt: z185.coerce.date(),
+  updatedAt: z185.coerce.date(),
+  path: z185.string(),
   /** Defined when a page has changed since last publish and can be included into a partial publish */
   draftState: DTODocumentationDraftState.optional(),
+  /** Defined if a page was published at least once and contains metadata about last publish */
+  publishMetadata: DTODocumentationPublishMetadata.optional(),
   // Backward compatibility
-  type: z184.literal("Page")
+  type: z185.literal("Page")
 });
-var DTOCreateDocumentationPageInputV2 = z184.object({
+var DTOCreateDocumentationPageInputV2 = z185.object({
   // Identifier
-  persistentId: z184.string().uuid(),
+  persistentId: z185.string().uuid(),
   // Page properties
-  title: z184.string(),
+  title: z185.string(),
   configuration: DTODocumentationItemConfigurationV2.partial().optional(),
   // Page placement properties
-  parentPersistentId: z184.string().uuid(),
-  afterPersistentId: z184.string().uuid().nullish()
+  parentPersistentId: z185.string().uuid(),
+  afterPersistentId: z185.string().uuid().nullish()
 });
-var DTOUpdateDocumentationPageInputV2 = z184.object({
+var DTOUpdateDocumentationPageInputV2 = z185.object({
   // Identifier of the group to update
-  id: z184.string(),
+  id: z185.string(),
   // Page properties
-  title: z184.string().optional(),
+  title: z185.string().optional(),
   configuration: DTODocumentationItemConfigurationV2.partial().optional()
 });
-var DTOMoveDocumentationPageInputV2 = z184.object({
+var DTOMoveDocumentationPageInputV2 = z185.object({
   // Identifier of the group to update
-  id: z184.string(),
+  id: z185.string(),
   // Page placement properties
-  parentPersistentId: z184.string().uuid(),
-  afterPersistentId: z184.string().uuid().nullish()
+  parentPersistentId: z185.string().uuid(),
+  afterPersistentId: z185.string().uuid().nullish()
 });
-var DTODuplicateDocumentationPageInputV2 = z184.object({
+var DTODuplicateDocumentationPageInputV2 = z185.object({
   // Identifier of the page to duplicate from
-  id: z184.string(),
+  id: z185.string(),
   // New page persistent id
-  persistentId: z184.string().uuid(),
+  persistentId: z185.string().uuid(),
   // Page placement properties
-  parentPersistentId: z184.string().uuid(),
-  afterPersistentId: z184.string().uuid().nullish()
+  parentPersistentId: z185.string().uuid(),
+  afterPersistentId: z185.string().uuid().nullish()
 });
-var DTODeleteDocumentationPageInputV2 = z184.object({
+var DTODeleteDocumentationPageInputV2 = z185.object({
   // Identifier
-  id: z184.string()
+  id: z185.string()
 });
-var DTORestoreDocumentationPageInput = z184.object({
-  persistentId: z184.string(),
-  snapshotId: z184.string().optional()
+var DTORestoreDocumentationPageInput = z185.object({
+  persistentId: z185.string(),
+  snapshotId: z185.string().optional()
 });
-var DTORestoreDocumentationGroupInput = z184.object({
-  persistentId: z184.string(),
-  snapshotId: z184.string().optional()
+var DTORestoreDocumentationGroupInput = z185.object({
+  persistentId: z185.string(),
+  snapshotId: z185.string().optional()
 });
 
 // src/api/dto/documentation/documentation-page-snapshot.ts
-var DTODocumentationPageSnapshot = z185.object({
-  id: z185.string(),
-  designSystemVersionId: z185.string(),
-  createdAt: z185.string(),
-  updatedAt: z185.string(),
+var DTODocumentationPageSnapshot = z186.object({
+  id: z186.string(),
+  designSystemVersionId: z186.string(),
+  createdAt: z186.string(),
+  updatedAt: z186.string(),
   documentationPage: DTODocumentationPageV2,
-  pageContentHash: z185.string(),
+  pageContentHash: z186.string(),
   reason: DesignElementSnapshotReason
 });
 
 // src/api/dto/documentation/link-preview.ts
-import { z as z186 } from "zod";
-var DTODocumentationLinkPreviewResponse = z186.object({
+import { z as z187 } from "zod";
+var DTODocumentationLinkPreviewResponse = z187.object({
   linkPreview: DocumentationLinkPreview
 });
-var DTODocumentationLinkPreviewRequest = z186.object({
-  url: z186.string().optional(),
-  documentationItemPersistentId: z186.string().optional()
+var DTODocumentationLinkPreviewRequest = z187.object({
+  url: z187.string().optional(),
+  documentationItemPersistentId: z187.string().optional()
 });
 
 // src/api/dto/documentation/publish.ts
-import { z as z190 } from "zod";
+import { z as z191 } from "zod";
 
 // src/api/dto/export/exporter.ts
-import { z as z187 } from "zod";
-var DTOExporterType = z187.enum(["documentation", "code"]);
-var DTOExporterSource = z187.enum(["git", "upload"]);
-var DTOExporterMembershipRole = z187.enum(["Owner", "OwnerArchived", "User"]);
-var DTOExporter = z187.object({
-  id: z187.string(),
-  name: z187.string(),
-  isPrivate: z187.boolean(),
+import { z as z188 } from "zod";
+var DTOExporterType = z188.enum(["documentation", "code"]);
+var DTOExporterSource = z188.enum(["git", "upload"]);
+var DTOExporterMembershipRole = z188.enum(["Owner", "OwnerArchived", "User"]);
+var DTOExporter = z188.object({
+  id: z188.string(),
+  name: z188.string(),
+  isPrivate: z188.boolean(),
   exporterType: DTOExporterType,
-  isDefaultDocumentationExporter: z187.boolean(),
-  iconURL: z187.string().optional(),
+  isDefaultDocumentationExporter: z188.boolean(),
+  iconURL: z188.string().optional(),
   configurationProperties: PulsarContributionConfigurationProperty.array(),
   customBlocks: PulsarCustomBlock.array(),
-  blockVariants: z187.record(z187.string(), PulsarContributionVariant.array()),
-  usesBrands: z187.boolean(),
-  usesThemes: z187.boolean(),
+  blockVariants: z188.record(z188.string(), PulsarContributionVariant.array()),
+  usesBrands: z188.boolean(),
+  usesThemes: z188.boolean(),
   source: DTOExporterSource,
-  gitUrl: z187.string().optional(),
-  gitBranch: z187.string().optional(),
-  gitDirectory: z187.string().optional()
+  gitUrl: z188.string().optional(),
+  gitBranch: z188.string().optional(),
+  gitDirectory: z188.string().optional()
 });
-var DTOExporterMembership = z187.object({
-  workspaceId: z187.string(),
-  exporterId: z187.string(),
+var DTOExporterMembership = z188.object({
+  workspaceId: z188.string(),
+  exporterId: z188.string(),
   role: DTOExporterMembershipRole
 });
-var DTOExporterCreateOutput = z187.object({
+var DTOExporterCreateOutput = z188.object({
   exporter: DTOExporter,
   membership: DTOExporterMembership
 });
-var DTOExporterGitProviderEnum = z187.enum(["github", "gitlab", "bitbucket", "azure"]);
-var DTOExporterCreateInput = z187.object({
-  url: z187.string(),
+var DTOExporterGitProviderEnum = z188.enum(["github", "gitlab", "bitbucket", "azure"]);
+var DTOExporterCreateInput = z188.object({
+  url: z188.string(),
   provider: DTOExporterGitProviderEnum
 });
-var DTOExporterUpdateInput = z187.object({
-  url: z187.string().optional()
+var DTOExporterUpdateInput = z188.object({
+  url: z188.string().optional()
 });
 
 // src/api/dto/export/job.ts
-import { z as z188 } from "zod";
-var DTOExportJobCreatedBy = z188.object({
-  userId: z188.string(),
-  userName: z188.string()
+import { z as z189 } from "zod";
+var DTOExportJobCreatedBy = z189.object({
+  userId: z189.string(),
+  userName: z189.string()
 });
-var DTOExportJobDesignSystemPreview = z188.object({
-  id: z188.string(),
+var DTOExportJobDesignSystemPreview = z189.object({
+  id: z189.string(),
   meta: ObjectMeta
 });
-var DTOExportJobDesignSystemVersionPreview = z188.object({
-  id: z188.string(),
+var DTOExportJobDesignSystemVersionPreview = z189.object({
+  id: z189.string(),
   meta: ObjectMeta,
-  version: z188.string(),
-  isReadonly: z188.boolean()
+  version: z189.string(),
+  isReadonly: z189.boolean()
 });
-var DTOExportJobDestinations = z188.object({
+var DTOExportJobDestinations = z189.object({
   s3: ExporterDestinationS3.optional(),
   azure: ExporterDestinationAzure.optional(),
   bitbucket: ExporterDestinationBitbucket.optional(),
   github: ExporterDestinationGithub.optional(),
   gitlab: ExporterDestinationGitlab.optional(),
   documentation: ExporterDestinationDocs.optional(),
-  webhookUrl: z188.string().optional()
+  webhookUrl: z189.string().optional()
 });
-var DTOExportJob = z188.object({
-  id: z188.string(),
-  createdAt: z188.coerce.date(),
-  finishedAt: z188.coerce.date().optional(),
-  index: z188.number().optional(),
+var DTOExportJob = z189.object({
+  id: z189.string(),
+  createdAt: z189.coerce.date(),
+  finishedAt: z189.coerce.date().optional(),
+  index: z189.number().optional(),
   status: ExportJobStatus,
-  estimatedExecutionTime: z188.number().optional(),
+  estimatedExecutionTime: z189.number().optional(),
   createdBy: DTOExportJobCreatedBy.optional(),
   designSystem: DTOExportJobDesignSystemPreview,
   designSystemVersion: DTOExportJobDesignSystemVersionPreview,
   destinations: DTOExportJobDestinations,
-  exporterId: z188.string(),
-  scheduleId: z188.string().optional(),
+  exporterId: z189.string(),
+  scheduleId: z189.string().optional(),
   result: ExportJobResult.optional(),
-  brandPersistentId: z188.string().optional(),
-  themePersistentId: z188.string().optional()
+  brandPersistentId: z189.string().optional(),
+  themePersistentId: z189.string().optional()
 });
-var DTOExportJobResponse = z188.object({
+var DTOExportJobResponse = z189.object({
   job: DTOExportJob
 });
 
 // src/api/dto/export/pipeline.ts
-import { z as z189 } from "zod";
-var DTOPipeline = z189.object({
-  id: z189.string(),
-  name: z189.string(),
+import { z as z190 } from "zod";
+var DTOPipeline = z190.object({
+  id: z190.string(),
+  name: z190.string(),
   eventType: PipelineEventType,
-  isEnabled: z189.boolean(),
-  workspaceId: z189.string(),
-  designSystemId: z189.string(),
-  exporterId: z189.string(),
-  brandPersistentId: z189.string().optional(),
-  themePersistentId: z189.string().optional(),
+  isEnabled: z190.boolean(),
+  workspaceId: z190.string(),
+  designSystemId: z190.string(),
+  exporterId: z190.string(),
+  brandPersistentId: z190.string().optional(),
+  themePersistentId: z190.string().optional(),
   ...ExportDestinationsMap.shape,
   latestJobs: DTOExportJob.array()
 });
 
 // src/api/dto/documentation/publish.ts
 var DTOPublishDocumentationChanges = ExportJobDocumentationChanges;
-var DTOPublishDocumentationRequest = z190.object({
+var DTOPublishDocumentationRequest = z191.object({
   environment: PublishedDocEnvironment,
   /**
    * If defined, this allows narrowing down what is published to a set of specific pages and groups
@@ -5280,15 +5304,15 @@ var DTOPublishDocumentationRequest = z190.object({
    */
   changes: DTOPublishDocumentationChanges.optional()
 });
-var DTOPublishDocumentationResponse = z190.object({
+var DTOPublishDocumentationResponse = z191.object({
   job: DTOExportJob
 });
 
 // src/api/dto/elements/documentation/group-action.ts
-import { z as z192 } from "zod";
+import { z as z193 } from "zod";
 
 // src/api/dto/elements/documentation/group-v2.ts
-import { z as z191 } from "zod";
+import { z as z192 } from "zod";
 var DTODocumentationGroupV2 = ElementGroup.omit({
   sortOrder: true,
   parentPersistentId: true,
@@ -5298,137 +5322,139 @@ var DTODocumentationGroupV2 = ElementGroup.omit({
   data: true,
   shortPersistentId: true
 }).extend({
-  title: z191.string(),
-  isRoot: z191.boolean(),
-  childrenIds: z191.array(z191.string()),
+  title: z192.string(),
+  isRoot: z192.boolean(),
+  childrenIds: z192.array(z192.string()),
   groupBehavior: DocumentationGroupBehavior,
-  shortPersistentId: z191.string(),
+  shortPersistentId: z192.string(),
   configuration: DTODocumentationItemConfigurationV2,
-  type: z191.literal("Group"),
+  type: z192.literal("Group"),
   /** Defined when a group has changed since last publish and can be included into a partial publish */
-  draftState: DTODocumentationDraftState.optional()
+  draftState: DTODocumentationDraftState.optional(),
+  /** Defined if a group was published at least once and contains metadata about last publish */
+  publishMetadata: DTODocumentationPublishMetadata.optional()
 });
-var DTOCreateDocumentationGroupInput = z191.object({
+var DTOCreateDocumentationGroupInput = z192.object({
   // Identifier
-  persistentId: z191.string().uuid(),
+  persistentId: z192.string().uuid(),
   // Group properties
-  title: z191.string(),
+  title: z192.string(),
   configuration: DTODocumentationItemConfigurationV2.partial().optional(),
   // Group placement properties
-  afterPersistentId: z191.string().uuid().nullish(),
-  parentPersistentId: z191.string().uuid()
+  afterPersistentId: z192.string().uuid().nullish(),
+  parentPersistentId: z192.string().uuid()
 });
-var DTOUpdateDocumentationGroupInput = z191.object({
+var DTOUpdateDocumentationGroupInput = z192.object({
   // Identifier of the group to update
-  id: z191.string(),
+  id: z192.string(),
   // Group properties
-  title: z191.string().optional(),
+  title: z192.string().optional(),
   configuration: DTODocumentationItemConfigurationV2.partial().optional()
 });
-var DTOMoveDocumentationGroupInput = z191.object({
+var DTOMoveDocumentationGroupInput = z192.object({
   // Identifier of the group to update
-  id: z191.string(),
+  id: z192.string(),
   // Group placement properties
-  parentPersistentId: z191.string().uuid(),
-  afterPersistentId: z191.string().uuid().nullish()
+  parentPersistentId: z192.string().uuid(),
+  afterPersistentId: z192.string().uuid().nullish()
 });
-var DTODuplicateDocumentationGroupInput = z191.object({
+var DTODuplicateDocumentationGroupInput = z192.object({
   // Identifier of the group to duplicate from
-  id: z191.string(),
+  id: z192.string(),
   // New group persistent id
-  persistentId: z191.string().uuid(),
+  persistentId: z192.string().uuid(),
   // Group placement properties
-  afterPersistentId: z191.string().uuid().nullish(),
-  parentPersistentId: z191.string().uuid()
+  afterPersistentId: z192.string().uuid().nullish(),
+  parentPersistentId: z192.string().uuid()
 });
-var DTOCreateDocumentationTabInput = z191.object({
+var DTOCreateDocumentationTabInput = z192.object({
   // New group persistent id
-  persistentId: z191.string().uuid(),
+  persistentId: z192.string().uuid(),
   // If this is page, we will attempt to convert it to tab
   // If this is tab group, we will add a new tab to it
-  fromItemPersistentId: z191.string(),
-  tabName: z191.string()
+  fromItemPersistentId: z192.string(),
+  tabName: z192.string()
 });
-var DTODeleteDocumentationTabGroupInput = z191.object({
+var DTODeleteDocumentationTabGroupInput = z192.object({
   // Deleted group id
-  id: z191.string()
+  id: z192.string()
 });
-var DTODeleteDocumentationGroupInput = z191.object({
+var DTODeleteDocumentationGroupInput = z192.object({
   // Identifier
-  id: z191.string(),
+  id: z192.string(),
   // Deletion options
-  deleteSubtree: z191.boolean().default(false)
+  deleteSubtree: z192.boolean().default(false)
 });
 
 // src/api/dto/elements/documentation/group-action.ts
-var SuccessPayload = z192.object({
-  success: z192.literal(true)
+var SuccessPayload = z193.object({
+  success: z193.literal(true)
 });
-var DTODocumentationGroupCreateActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationGroupCreate"),
+var DTODocumentationGroupCreateActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationGroupCreate"),
   output: SuccessPayload
 });
-var DTODocumentationTabCreateActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationTabCreate"),
+var DTODocumentationTabCreateActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationTabCreate"),
   output: SuccessPayload
 });
-var DTODocumentationGroupUpdateActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationGroupUpdate"),
+var DTODocumentationGroupUpdateActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationGroupUpdate"),
   output: SuccessPayload
 });
-var DTODocumentationGroupMoveActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationGroupMove"),
+var DTODocumentationGroupMoveActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationGroupMove"),
   output: SuccessPayload
 });
-var DTODocumentationGroupDuplicateActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationGroupDuplicate"),
+var DTODocumentationGroupDuplicateActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationGroupDuplicate"),
   output: SuccessPayload
 });
-var DTODocumentationGroupDeleteActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationGroupDelete"),
+var DTODocumentationGroupDeleteActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationGroupDelete"),
   output: SuccessPayload
 });
-var DTODocumentationTabGroupDeleteActionOutputV2 = z192.object({
-  type: z192.literal("DocumentationTabGroupDelete"),
+var DTODocumentationTabGroupDeleteActionOutputV2 = z193.object({
+  type: z193.literal("DocumentationTabGroupDelete"),
   output: SuccessPayload
 });
-var DTODocumentationGroupCreateActionInputV2 = z192.object({
-  type: z192.literal("DocumentationGroupCreate"),
+var DTODocumentationGroupCreateActionInputV2 = z193.object({
+  type: z193.literal("DocumentationGroupCreate"),
   input: DTOCreateDocumentationGroupInput
 });
-var DTODocumentationTabCreateActionInputV2 = z192.object({
-  type: z192.literal("DocumentationTabCreate"),
+var DTODocumentationTabCreateActionInputV2 = z193.object({
+  type: z193.literal("DocumentationTabCreate"),
   input: DTOCreateDocumentationTabInput
 });
-var DTODocumentationGroupUpdateActionInputV2 = z192.object({
-  type: z192.literal("DocumentationGroupUpdate"),
+var DTODocumentationGroupUpdateActionInputV2 = z193.object({
+  type: z193.literal("DocumentationGroupUpdate"),
   input: DTOUpdateDocumentationGroupInput
 });
-var DTODocumentationGroupMoveActionInputV2 = z192.object({
-  type: z192.literal("DocumentationGroupMove"),
+var DTODocumentationGroupMoveActionInputV2 = z193.object({
+  type: z193.literal("DocumentationGroupMove"),
   input: DTOMoveDocumentationGroupInput
 });
-var DTODocumentationGroupDuplicateActionInputV2 = z192.object({
-  type: z192.literal("DocumentationGroupDuplicate"),
+var DTODocumentationGroupDuplicateActionInputV2 = z193.object({
+  type: z193.literal("DocumentationGroupDuplicate"),
   input: DTODuplicateDocumentationGroupInput
 });
-var DTODocumentationGroupDeleteActionInputV2 = z192.object({
-  type: z192.literal("DocumentationGroupDelete"),
+var DTODocumentationGroupDeleteActionInputV2 = z193.object({
+  type: z193.literal("DocumentationGroupDelete"),
   input: DTODeleteDocumentationGroupInput
 });
-var DTODocumentationTabGroupDeleteActionInputV2 = z192.object({
-  type: z192.literal("DocumentationTabGroupDelete"),
+var DTODocumentationTabGroupDeleteActionInputV2 = z193.object({
+  type: z193.literal("DocumentationTabGroupDelete"),
   input: DTODeleteDocumentationTabGroupInput
 });
 
 // src/api/dto/elements/documentation/group-v1.ts
-import { z as z194 } from "zod";
+import { z as z195 } from "zod";
 
 // src/api/dto/elements/documentation/item-configuration-v1.ts
-import { z as z193 } from "zod";
-var DocumentationColorV1 = z193.object({
-  aliasTo: z193.string().optional(),
-  value: z193.string().optional()
+import { z as z194 } from "zod";
+var DocumentationColorV1 = z194.object({
+  aliasTo: z194.string().optional(),
+  value: z194.string().optional()
 });
 var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
   foregroundColor: true,
@@ -5437,10 +5463,10 @@ var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
   foregroundColor: DocumentationColorV1.optional(),
   backgroundColor: DocumentationColorV1.optional()
 });
-var DTODocumentationItemConfigurationV1 = z193.object({
-  showSidebar: z193.boolean(),
-  isPrivate: z193.boolean(),
-  isHidden: z193.boolean(),
+var DTODocumentationItemConfigurationV1 = z194.object({
+  showSidebar: z194.boolean(),
+  isPrivate: z194.boolean(),
+  isHidden: z194.boolean(),
   header: DTODocumentationItemHeaderV1
 });
 
@@ -5454,117 +5480,105 @@ var DTODocumentationGroupStructureV1 = ElementGroup.omit({
   data: true,
   shortPersistentId: true
 }).extend({
-  title: z194.string(),
-  isRoot: z194.boolean(),
-  childrenIds: z194.array(z194.string()),
+  title: z195.string(),
+  isRoot: z195.boolean(),
+  childrenIds: z195.array(z195.string()),
   groupBehavior: DocumentationGroupBehavior,
-  shortPersistentId: z194.string(),
-  type: z194.literal("Group")
+  shortPersistentId: z195.string(),
+  type: z195.literal("Group")
 });
 var DTODocumentationGroupV1 = DTODocumentationGroupStructureV1.extend({
   configuration: DTODocumentationItemConfigurationV1
 });
 
 // src/api/dto/elements/documentation/hierarchy.ts
-import { z as z195 } from "zod";
-var DTODocumentationHierarchyV2 = z195.object({
-  pages: z195.array(
+import { z as z196 } from "zod";
+var DTODocumentationHierarchyV2 = z196.object({
+  pages: z196.array(
     DTODocumentationPageV2.extend({
       /** Defined when a page has changed since last publish and can be included into a partial publish */
       draftState: DTODocumentationDraftState.optional()
     })
   ),
-  groups: z195.array(
+  groups: z196.array(
     DTODocumentationGroupV2.extend({
       /** Defined when a page has changed since last publish and can be included into a partial publish */
       draftState: DTODocumentationDraftState.optional()
     })
-  ),
-  deletedPages: z195.array(
-    DTODocumentationPageV2.extend({
-      /** Deleted page is always a draft change */
-      draftState: DTODocumentationDraftState
-    })
-  ),
-  deletedGroups: z195.array(
-    DTODocumentationGroupV2.extend({
-      /** Deleted page is always a draft change */
-      draftState: DTODocumentationDraftState
-    })
   )
 });
 
 // src/api/dto/elements/documentation/page-actions-v2.ts
-import { z as z196 } from "zod";
-var SuccessPayload2 = z196.object({
-  success: z196.literal(true)
+import { z as z197 } from "zod";
+var SuccessPayload2 = z197.object({
+  success: z197.literal(true)
 });
-var DTODocumentationPageCreateActionOutputV2 = z196.object({
-  type: z196.literal("DocumentationPageCreate"),
+var DTODocumentationPageCreateActionOutputV2 = z197.object({
+  type: z197.literal("DocumentationPageCreate"),
   output: SuccessPayload2
 });
-var DTODocumentationPageUpdateActionOutputV2 = z196.object({
-  type: z196.literal("DocumentationPageUpdate"),
+var DTODocumentationPageUpdateActionOutputV2 = z197.object({
+  type: z197.literal("DocumentationPageUpdate"),
   output: SuccessPayload2
 });
-var DTODocumentationPageMoveActionOutputV2 = z196.object({
-  type: z196.literal("DocumentationPageMove"),
+var DTODocumentationPageMoveActionOutputV2 = z197.object({
+  type: z197.literal("DocumentationPageMove"),
   output: SuccessPayload2
 });
-var DTODocumentationPageDuplicateActionOutputV2 = z196.object({
-  type: z196.literal("DocumentationPageDuplicate"),
+var DTODocumentationPageDuplicateActionOutputV2 = z197.object({
+  type: z197.literal("DocumentationPageDuplicate"),
   output: SuccessPayload2
 });
-var DTODocumentationPageDeleteActionOutputV2 = z196.object({
-  type: z196.literal("DocumentationPageDelete"),
+var DTODocumentationPageDeleteActionOutputV2 = z197.object({
+  type: z197.literal("DocumentationPageDelete"),
   output: SuccessPayload2
 });
-var DTODocumentationPageRestoreActionOutput = z196.object({
-  type: z196.literal("DocumentationPageRestore"),
+var DTODocumentationPageRestoreActionOutput = z197.object({
+  type: z197.literal("DocumentationPageRestore"),
   output: SuccessPayload2
 });
-var DTODocumentationGroupRestoreActionOutput = z196.object({
-  type: z196.literal("DocumentationGroupRestore"),
+var DTODocumentationGroupRestoreActionOutput = z197.object({
+  type: z197.literal("DocumentationGroupRestore"),
   output: SuccessPayload2
 });
-var DTODocumentationPageCreateActionInputV2 = z196.object({
-  type: z196.literal("DocumentationPageCreate"),
+var DTODocumentationPageCreateActionInputV2 = z197.object({
+  type: z197.literal("DocumentationPageCreate"),
   input: DTOCreateDocumentationPageInputV2
 });
-var DTODocumentationPageUpdateActionInputV2 = z196.object({
-  type: z196.literal("DocumentationPageUpdate"),
+var DTODocumentationPageUpdateActionInputV2 = z197.object({
+  type: z197.literal("DocumentationPageUpdate"),
   input: DTOUpdateDocumentationPageInputV2
 });
-var DTODocumentationPageMoveActionInputV2 = z196.object({
-  type: z196.literal("DocumentationPageMove"),
+var DTODocumentationPageMoveActionInputV2 = z197.object({
+  type: z197.literal("DocumentationPageMove"),
   input: DTOMoveDocumentationPageInputV2
 });
-var DTODocumentationPageDuplicateActionInputV2 = z196.object({
-  type: z196.literal("DocumentationPageDuplicate"),
+var DTODocumentationPageDuplicateActionInputV2 = z197.object({
+  type: z197.literal("DocumentationPageDuplicate"),
   input: DTODuplicateDocumentationPageInputV2
 });
-var DTODocumentationPageDeleteActionInputV2 = z196.object({
-  type: z196.literal("DocumentationPageDelete"),
+var DTODocumentationPageDeleteActionInputV2 = z197.object({
+  type: z197.literal("DocumentationPageDelete"),
   input: DTODeleteDocumentationPageInputV2
 });
-var DTODocumentationPageRestoreActionInput = z196.object({
-  type: z196.literal("DocumentationPageRestore"),
+var DTODocumentationPageRestoreActionInput = z197.object({
+  type: z197.literal("DocumentationPageRestore"),
   input: DTORestoreDocumentationPageInput
 });
-var DTODocumentationGroupRestoreActionInput = z196.object({
-  type: z196.literal("DocumentationGroupRestore"),
+var DTODocumentationGroupRestoreActionInput = z197.object({
+  type: z197.literal("DocumentationGroupRestore"),
   input: DTORestoreDocumentationGroupInput
 });
 
 // src/api/dto/elements/documentation/page-content.ts
-import { z as z197 } from "zod";
+import { z as z198 } from "zod";
 var DTODocumentationPageContent = DocumentationPageContent;
-var DTODocumentationPageContentGetResponse = z197.object({
+var DTODocumentationPageContentGetResponse = z198.object({
   pageContent: DTODocumentationPageContent
 });
 
 // src/api/dto/elements/documentation/page-v1.ts
-import { z as z198 } from "zod";
+import { z as z199 } from "zod";
 var DocumentationPageV1DTO = DocumentationPageV1.omit({
   data: true,
   meta: true,
@@ -5572,30 +5586,30 @@ var DocumentationPageV1DTO = DocumentationPageV1.omit({
   sortOrder: true
 }).extend({
   configuration: DTODocumentationItemConfigurationV1,
-  blocks: z198.array(PageBlockV1),
-  title: z198.string(),
-  path: z198.string()
+  blocks: z199.array(PageBlockV1),
+  title: z199.string(),
+  path: z199.string()
 });
 
 // src/api/dto/elements/figma-nodes/figma-node.ts
-import { z as z199 } from "zod";
-var DTOFigmaNodeOrigin = z199.object({
-  sourceId: z199.string(),
-  fileId: z199.string().optional(),
-  parentName: z199.string().optional()
+import { z as z200 } from "zod";
+var DTOFigmaNodeOrigin = z200.object({
+  sourceId: z200.string(),
+  fileId: z200.string().optional(),
+  parentName: z200.string().optional()
 });
-var DTOFigmaNodeData = z199.object({
+var DTOFigmaNodeData = z200.object({
   // Id of the node in the Figma file
-  figmaNodeId: z199.string(),
+  figmaNodeId: z200.string(),
   // Validity
-  isValid: z199.boolean(),
+  isValid: z200.boolean(),
   // Asset data
-  assetId: z199.string(),
-  assetUrl: z199.string(),
+  assetId: z200.string(),
+  assetUrl: z200.string(),
   // Asset metadata
-  assetScale: z199.number(),
-  assetWidth: z199.number().optional(),
-  assetHeight: z199.number().optional()
+  assetScale: z200.number(),
+  assetWidth: z200.number().optional(),
+  assetHeight: z200.number().optional()
 });
 var DTOFigmaNode = FigmaFileStructure.omit({
   data: true,
@@ -5604,105 +5618,105 @@ var DTOFigmaNode = FigmaFileStructure.omit({
   data: DTOFigmaNodeData,
   origin: DTOFigmaNodeOrigin
 });
-var DTOFigmaNodeRenderInput = z199.object({
+var DTOFigmaNodeRenderInput = z200.object({
   // Id of a design system's data source representing a linked Figma file
-  sourceId: z199.string(),
+  sourceId: z200.string(),
   // Id of a node within the Figma file
-  figmaFileNodeId: z199.string()
+  figmaFileNodeId: z200.string()
 });
 
 // src/api/dto/elements/figma-nodes/node-actions-v2.ts
-import { z as z200 } from "zod";
-var DTOFigmaNodeRenderActionOutput = z200.object({
-  type: z200.literal("FigmaNodeRender"),
-  figmaNodes: z200.array(DTOFigmaNode)
+import { z as z201 } from "zod";
+var DTOFigmaNodeRenderActionOutput = z201.object({
+  type: z201.literal("FigmaNodeRender"),
+  figmaNodes: z201.array(DTOFigmaNode)
 });
-var DTOFigmaNodeRenderActionInput = z200.object({
-  type: z200.literal("FigmaNodeRender"),
+var DTOFigmaNodeRenderActionInput = z201.object({
+  type: z201.literal("FigmaNodeRender"),
   input: DTOFigmaNodeRenderInput.array()
 });
 
 // src/api/dto/elements/properties/property-definitions-actions-v2.ts
-import { z as z202 } from "zod";
+import { z as z203 } from "zod";
 
 // src/api/dto/elements/properties/property-definitions.ts
-import { z as z201 } from "zod";
+import { z as z202 } from "zod";
 var CODE_NAME_REGEX2 = /^[a-zA-Z_$][a-zA-Z_$0-9]{1,99}$/;
-var DTOElementPropertyDefinition = z201.object({
-  id: z201.string(),
-  designSystemVersionId: z201.string(),
+var DTOElementPropertyDefinition = z202.object({
+  id: z202.string(),
+  designSystemVersionId: z202.string(),
   meta: ObjectMeta,
-  persistentId: z201.string(),
+  persistentId: z202.string(),
   type: ElementPropertyTypeSchema,
   targetElementType: ElementPropertyTargetType,
-  codeName: z201.string().regex(CODE_NAME_REGEX2),
-  options: z201.array(ElementPropertyDefinitionOption).optional(),
+  codeName: z202.string().regex(CODE_NAME_REGEX2),
+  options: z202.array(ElementPropertyDefinitionOption).optional(),
   linkElementType: ElementPropertyLinkType.optional()
 });
-var DTOElementPropertyDefinitionsGetResponse = z201.object({
-  definitions: z201.array(DTOElementPropertyDefinition)
+var DTOElementPropertyDefinitionsGetResponse = z202.object({
+  definitions: z202.array(DTOElementPropertyDefinition)
 });
 var DTOCreateElementPropertyDefinitionInputV2 = DTOElementPropertyDefinition.omit({
   id: true,
   designSystemVersionId: true
 });
-var DTOUpdateElementPropertyDefinitionInputV2 = z201.object({
-  id: z201.string(),
-  name: z201.string().optional(),
-  description: z201.string().optional(),
-  codeName: z201.string().regex(CODE_NAME_REGEX2).optional(),
-  options: z201.array(ElementPropertyDefinitionOption).optional()
+var DTOUpdateElementPropertyDefinitionInputV2 = z202.object({
+  id: z202.string(),
+  name: z202.string().optional(),
+  description: z202.string().optional(),
+  codeName: z202.string().regex(CODE_NAME_REGEX2).optional(),
+  options: z202.array(ElementPropertyDefinitionOption).optional()
 });
-var DTODeleteElementPropertyDefinitionInputV2 = z201.object({
-  id: z201.string()
+var DTODeleteElementPropertyDefinitionInputV2 = z202.object({
+  id: z202.string()
 });
 
 // src/api/dto/elements/properties/property-definitions-actions-v2.ts
-var SuccessPayload3 = z202.object({
-  success: z202.literal(true)
+var SuccessPayload3 = z203.object({
+  success: z203.literal(true)
 });
-var DTOPropertyDefinitionCreateActionOutputV2 = z202.object({
-  type: z202.literal("PropertyDefinitionCreate"),
+var DTOPropertyDefinitionCreateActionOutputV2 = z203.object({
+  type: z203.literal("PropertyDefinitionCreate"),
   definition: DTOElementPropertyDefinition
 });
-var DTOPropertyDefinitionUpdateActionOutputV2 = z202.object({
-  type: z202.literal("PropertyDefinitionUpdate"),
+var DTOPropertyDefinitionUpdateActionOutputV2 = z203.object({
+  type: z203.literal("PropertyDefinitionUpdate"),
   definition: DTOElementPropertyDefinition
 });
-var DTOPropertyDefinitionDeleteActionOutputV2 = z202.object({
-  type: z202.literal("PropertyDefinitionDelete"),
+var DTOPropertyDefinitionDeleteActionOutputV2 = z203.object({
+  type: z203.literal("PropertyDefinitionDelete"),
   output: SuccessPayload3
 });
-var DTOPropertyDefinitionCreateActionInputV2 = z202.object({
-  type: z202.literal("PropertyDefinitionCreate"),
+var DTOPropertyDefinitionCreateActionInputV2 = z203.object({
+  type: z203.literal("PropertyDefinitionCreate"),
   input: DTOCreateElementPropertyDefinitionInputV2
 });
-var DTOPropertyDefinitionUpdateActionInputV2 = z202.object({
-  type: z202.literal("PropertyDefinitionUpdate"),
+var DTOPropertyDefinitionUpdateActionInputV2 = z203.object({
+  type: z203.literal("PropertyDefinitionUpdate"),
   input: DTOUpdateElementPropertyDefinitionInputV2
 });
-var DTOPropertyDefinitionDeleteActionInputV2 = z202.object({
-  type: z202.literal("PropertyDefinitionDelete"),
+var DTOPropertyDefinitionDeleteActionInputV2 = z203.object({
+  type: z203.literal("PropertyDefinitionDelete"),
   input: DTODeleteElementPropertyDefinitionInputV2
 });
 
 // src/api/dto/elements/properties/property-values.ts
-import { z as z203 } from "zod";
-var DTOElementPropertyValue = z203.object({
-  id: z203.string(),
-  designSystemVersionId: z203.string(),
-  definitionId: z203.string(),
-  targetElementId: z203.string(),
-  value: z203.union([z203.string(), z203.number(), z203.boolean()]).optional(),
-  valuePreview: z203.string().optional()
+import { z as z204 } from "zod";
+var DTOElementPropertyValue = z204.object({
+  id: z204.string(),
+  designSystemVersionId: z204.string(),
+  definitionId: z204.string(),
+  targetElementId: z204.string(),
+  value: z204.union([z204.string(), z204.number(), z204.boolean()]).optional(),
+  valuePreview: z204.string().optional()
 });
-var DTOElementPropertyValuesGetResponse = z203.object({
-  values: z203.array(DTOElementPropertyValue)
+var DTOElementPropertyValuesGetResponse = z204.object({
+  values: z204.array(DTOElementPropertyValue)
 });
 
 // src/api/dto/elements/elements-action-v2.ts
-import { z as z204 } from "zod";
-var DTOElementActionOutput = z204.discriminatedUnion("type", [
+import { z as z205 } from "zod";
+var DTOElementActionOutput = z205.discriminatedUnion("type", [
   // Documentation pages
   DTODocumentationPageCreateActionOutputV2,
   DTODocumentationPageUpdateActionOutputV2,
@@ -5727,7 +5741,7 @@ var DTOElementActionOutput = z204.discriminatedUnion("type", [
   DTODocumentationPageRestoreActionOutput,
   DTODocumentationGroupRestoreActionOutput
 ]);
-var DTOElementActionInput = z204.discriminatedUnion("type", [
+var DTOElementActionInput = z205.discriminatedUnion("type", [
   // Documentation pages
   DTODocumentationPageCreateActionInputV2,
   DTODocumentationPageUpdateActionInputV2,
@@ -5754,141 +5768,141 @@ var DTOElementActionInput = z204.discriminatedUnion("type", [
 ]);
 
 // src/api/dto/elements/get-elements-v2.ts
-import { z as z205 } from "zod";
-var DTOElementsGetTypeFilter = z205.enum(["FigmaNode"]);
-var DTOElementsGetQuerySchema = z205.object({
-  types: z205.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
+import { z as z206 } from "zod";
+var DTOElementsGetTypeFilter = z206.enum(["FigmaNode"]);
+var DTOElementsGetQuerySchema = z206.object({
+  types: z206.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
 });
-var DTOElementsGetOutput = z205.object({
-  figmaNodes: z205.array(DTOFigmaNode).optional()
+var DTOElementsGetOutput = z206.object({
+  figmaNodes: z206.array(DTOFigmaNode).optional()
 });
 
 // src/api/dto/figma-components/assets/download.ts
-import { z as z206 } from "zod";
-var DTOAssetRenderConfiguration = z206.object({
-  prefix: z206.string().optional(),
-  suffix: z206.string().optional(),
-  scale: z206.enum(["x1", "x2", "x3", "x4"]),
-  format: z206.enum(["png", "pdf", "svg"])
-});
-var DTORenderedAssetFile = z206.object({
-  assetId: z206.string(),
-  fileName: z206.string(),
-  sourceUrl: z206.string(),
+import { z as z207 } from "zod";
+var DTOAssetRenderConfiguration = z207.object({
+  prefix: z207.string().optional(),
+  suffix: z207.string().optional(),
+  scale: z207.enum(["x1", "x2", "x3", "x4"]),
+  format: z207.enum(["png", "pdf", "svg"])
+});
+var DTORenderedAssetFile = z207.object({
+  assetId: z207.string(),
+  fileName: z207.string(),
+  sourceUrl: z207.string(),
   settings: DTOAssetRenderConfiguration,
-  originalName: z206.string()
+  originalName: z207.string()
 });
-var DTODownloadAssetsRequest = z206.object({
-  persistentIds: z206.array(z206.string().uuid()).optional(),
+var DTODownloadAssetsRequest = z207.object({
+  persistentIds: z207.array(z207.string().uuid()).optional(),
   settings: DTOAssetRenderConfiguration.array()
 });
-var DTODownloadAssetsResponse = z206.object({
+var DTODownloadAssetsResponse = z207.object({
   items: DTORenderedAssetFile.array()
 });
 
 // src/api/dto/liveblocks/auth-response.ts
-import { z as z207 } from "zod";
-var DTOLiveblocksAuthResponse = z207.object({
-  token: z207.string()
+import { z as z208 } from "zod";
+var DTOLiveblocksAuthResponse = z208.object({
+  token: z208.string()
 });
 
 // src/api/dto/users/profile/update.ts
-import { z as z208 } from "zod";
-var DTOUserProfileUpdateResponse = z208.object({
+import { z as z209 } from "zod";
+var DTOUserProfileUpdateResponse = z209.object({
   user: User
 });
 
 // src/api/dto/workspaces/git.ts
-import { z as z209 } from "zod";
-var DTOGitOrganization = z209.object({
-  id: z209.string(),
-  name: z209.string(),
-  url: z209.string(),
-  slug: z209.string()
-});
-var DTOGitProject = z209.object({
-  id: z209.string(),
-  name: z209.string(),
-  url: z209.string(),
-  slug: z209.string()
-});
-var DTOGitRepository = z209.object({
-  id: z209.string(),
-  name: z209.string(),
-  url: z209.string(),
-  slug: z209.string(),
-  defaultBranch: z209.string().optional()
-});
-var DTOGitBranch = z209.object({
-  name: z209.string(),
-  lastCommitId: z209.string()
+import { z as z210 } from "zod";
+var DTOGitOrganization = z210.object({
+  id: z210.string(),
+  name: z210.string(),
+  url: z210.string(),
+  slug: z210.string()
+});
+var DTOGitProject = z210.object({
+  id: z210.string(),
+  name: z210.string(),
+  url: z210.string(),
+  slug: z210.string()
+});
+var DTOGitRepository = z210.object({
+  id: z210.string(),
+  name: z210.string(),
+  url: z210.string(),
+  slug: z210.string(),
+  defaultBranch: z210.string().optional()
+});
+var DTOGitBranch = z210.object({
+  name: z210.string(),
+  lastCommitId: z210.string()
 });
 
 // src/api/dto/workspaces/integrations.ts
-import { z as z210 } from "zod";
+import { z as z211 } from "zod";
 var DTOIntegrationCredentials = IntegrationCredentials.omit({
   accessToken: true,
   refreshToken: true
 });
-var DTOIntegration = z210.object({
-  id: z210.string(),
-  workspaceId: z210.string(),
+var DTOIntegration = z211.object({
+  id: z211.string(),
+  workspaceId: z211.string(),
   type: ExtendedIntegrationType,
-  createdAt: z210.coerce.date(),
-  integrationCredentials: z210.array(DTOIntegrationCredentials).optional(),
-  integrationDesignSystems: z210.array(IntegrationDesignSystem).optional()
+  createdAt: z211.coerce.date(),
+  integrationCredentials: z211.array(DTOIntegrationCredentials).optional(),
+  integrationDesignSystems: z211.array(IntegrationDesignSystem).optional()
 });
-var DTOIntegrationOAuthGetResponse = z210.object({
-  url: z210.string()
+var DTOIntegrationOAuthGetResponse = z211.object({
+  url: z211.string()
 });
-var DTOIntegrationPostResponse = z210.object({
+var DTOIntegrationPostResponse = z211.object({
   integration: DTOIntegration
 });
-var DTOIntegrationsGetListResponse = z210.object({
+var DTOIntegrationsGetListResponse = z211.object({
   integrations: DTOIntegration.array()
 });
 
 // src/api/dto/workspaces/membership.ts
-import { z as z213 } from "zod";
+import { z as z214 } from "zod";
 
 // src/api/dto/workspaces/workspace.ts
-import { z as z212 } from "zod";
+import { z as z213 } from "zod";
 
 // src/api/dto/workspaces/npm-registry.ts
-import { z as z211 } from "zod";
+import { z as z212 } from "zod";
 var DTONpmRegistryConfigConstants = {
   passwordPlaceholder: "redacted"
 };
-var DTONpmRegistryConfig = z211.object({
+var DTONpmRegistryConfig = z212.object({
   // Registry basic configuration
   registryType: NpmRegistryType,
-  registryUrl: z211.string(),
-  customRegistryUrl: z211.string().optional(),
+  registryUrl: z212.string(),
+  customRegistryUrl: z212.string().optional(),
   // URL of Supernova NPM packages proxy
-  proxyUrl: z211.string(),
+  proxyUrl: z212.string(),
   // Auth configuration
   authType: NpmRegistryAuthType,
-  accessToken: z211.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
-  username: z211.string().optional(),
-  password: z211.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
+  accessToken: z212.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
+  username: z212.string().optional(),
+  password: z212.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
   // NPM package scopes for whih the proxy should be enabled
-  enabledScopes: z211.array(z211.string()),
+  enabledScopes: z212.array(z212.string()),
   // True if client should bypass Supernova proxy and connect directly to the registry
   // (e.g. when the NPM registry is behind a VPN or firewall which prevents Supernova from accessing it)
-  bypassProxy: z211.boolean()
+  bypassProxy: z212.boolean()
 });
 
 // src/api/dto/workspaces/workspace.ts
-var DTOWorkspace = z212.object({
-  id: z212.string(),
+var DTOWorkspace = z213.object({
+  id: z213.string(),
   profile: WorkspaceProfile,
   subscription: Subscription,
   npmRegistry: DTONpmRegistryConfig.optional()
 });
 
 // src/api/dto/workspaces/membership.ts
-var DTOWorkspaceRole = z213.enum(["Owner", "Admin", "Creator", "Viewer", "Billing"]);
-var DTOUserWorkspaceMembership = z213.object({
+var DTOWorkspaceRole = z214.enum(["Owner", "Admin", "Creator", "Viewer", "Billing"]);
+var DTOUserWorkspaceMembership = z214.object({
   // Workspace the user is a member of
   workspace: DTOWorkspace,
   // Assigned role the user has in the workspace
@@ -5898,8 +5912,8 @@ var DTOUserWorkspaceMembership = z213.object({
   // when a workspace's subscription is downgraded to free tier
   effectiveRole: DTOWorkspaceRole
 });
-var DTOUserWorkspaceMembershipsResponse = z213.object({
-  membership: z213.array(DTOUserWorkspaceMembership)
+var DTOUserWorkspaceMembershipsResponse = z214.object({
+  membership: z214.array(DTOUserWorkspaceMembership)
 });
 
 // src/utils/hash.ts
@@ -5961,7 +5975,7 @@ function generateHash(input, debug = false) {
 }
 
 // src/yjs/design-system-content/documentation-hierarchy.ts
-import { z as z214 } from "zod";
+import { z as z215 } from "zod";
 
 // src/yjs/version-room/base.ts
 var VersionRoomBaseYDoc = class {
@@ -6131,7 +6145,8 @@ var FrontendVersionRoomYDoc = class {
   //
   // Hierarchy
   //
-  getDocumentationHierarchy() {
+  getDocumentationHierarchy(options = {}) {
+    const { includeDeletedContent } = options;
     const doc = new VersionRoomBaseYDoc(this.yDoc);
     const pages = doc.getPages();
     const groups = doc.getGroups();
@@ -6143,48 +6158,28 @@ var FrontendVersionRoomYDoc = class {
     if (!settings.isDraftFeatureAdopted) {
       return {
         pages: pageDTOs,
-        groups: groupDTOs,
-        deletedGroups: [],
-        deletedPages: []
+        groups: groupDTOs
       };
     }
     const pageDraftStates = this.buildPageDraftStates(pages, pageSnapshots);
+    const pagePublishedMetadata = this.buildPagePublishedMetadata(pages, pageSnapshots);
     pageDTOs.forEach((p) => {
       const draftState = pageDraftStates.get(p.id);
       draftState && (p.draftState = draftState);
+      const publishMetadata = pagePublishedMetadata.get(p.id);
+      publishMetadata && (p.publishMetadata = publishMetadata);
     });
     const groupDraftStates = this.buildGroupDraftStates(groups, groupSnapshots);
+    const groupPublishedMetadata = this.buildGroupPublishedMetadata(groups, groupSnapshots);
     groupDTOs.forEach((g) => {
       const draftState = groupDraftStates.get(g.id);
       draftState && (g.draftState = draftState);
-    });
-    const pageIds = new Set(pages.map((p) => p.id));
-    const deletedPagesMap = mapByUnique(
-      pageSnapshots.filter((s) => !pageIds.has(s.page.id)).map((s) => s.page),
-      (p) => p.id
-    );
-    const deletedPages = Array.from(deletedPagesMap.values());
-    const groupIds = new Set(groups.map((p) => p.id));
-    const deletedGroupsMap = mapByUnique(
-      groupSnapshots.filter((s) => !groupIds.has(s.group.id)).map((s) => s.group),
-      (g) => g.id
-    );
-    const deletedGroups = Array.from(deletedGroupsMap.values());
-    const deletedPageDTOs = documentationPagesToDTOV2(
-      deletedPages,
-      [...groups, ...deletedGroups],
-      settings.routingVersion
-    ).map((p) => {
-      return { ...p, draftState: { changeType: "Deleted" } };
-    });
-    const deletedGroupDTOs = elementGroupsToDocumentationGroupDTOV2(deletedGroups, deletedPages).map((g) => {
-      return { ...g, draftState: { changeType: "Deleted" } };
+      const publishMetadata = groupPublishedMetadata.get(g.id);
+      publishMetadata && (g.publishMetadata = publishMetadata);
     });
     return {
       pages: pageDTOs,
-      groups: groupDTOs,
-      deletedPages: deletedPageDTOs,
-      deletedGroups: deletedGroupDTOs
+      groups: groupDTOs
     };
   }
   //
@@ -6215,6 +6210,40 @@ var FrontendVersionRoomYDoc = class {
     });
     return result;
   }
+  buildPagePublishedMetadata(pages, pageSnapshots) {
+    const publishedPageSnapshotsById = mapByUnique(
+      pickLatestPageSnapshots(pageSnapshots.filter((s) => s.reason === "Publish")),
+      (s) => s.page.id
+    );
+    const result = /* @__PURE__ */ new Map();
+    pages.forEach((p) => {
+      const publishedSnapshot = publishedPageSnapshotsById.get(p.id);
+      if (!publishedSnapshot)
+        return;
+      result.set(p.id, {
+        lastPublishedAt: publishedSnapshot.createdAt,
+        lastPublishedByUserId: publishedSnapshot.createdByUserId
+      });
+    });
+    return result;
+  }
+  buildGroupPublishedMetadata(groups, groupSnapshots) {
+    const publishedGroupSnapshotsById = mapByUnique(
+      pickLatestGroupSnapshots(groupSnapshots.filter((s) => s.reason === "Publish")),
+      (s) => s.group.id
+    );
+    const result = /* @__PURE__ */ new Map();
+    groups.forEach((g) => {
+      const publishedSnapshot = publishedGroupSnapshotsById.get(g.id);
+      if (!publishedSnapshot)
+        return;
+      result.set(g.id, {
+        lastPublishedAt: publishedSnapshot.createdAt,
+        lastPublishedByUserId: publishedSnapshot.createdByUserId
+      });
+    });
+    return result;
+  }
   itemStateFromPage(page, pageContentHash) {
     return {
       title: page.meta.name,
@@ -6312,25 +6341,29 @@ var FrontendVersionRoomYDoc = class {
     const settings = doc.getDocumentationInternalSettings();
     return settings.isDraftFeatureAdopted;
   }
+  hasPublishedDocumentationContent() {
+    const doc = new VersionRoomBaseYDoc(this.yDoc);
+    return doc.getPageSnapshots().filter((s) => s.reason === "Publish").length > 0 || doc.getGroupSnapshots().filter((s) => s.reason === "Publish").length > 0;
+  }
 };
 
 // src/yjs/design-system-content/documentation-hierarchy.ts
-var DocumentationHierarchySettings = z214.object({
-  routingVersion: z214.string(),
-  isDraftFeatureAdopted: z214.boolean()
+var DocumentationHierarchySettings = z215.object({
+  routingVersion: z215.string(),
+  isDraftFeatureAdopted: z215.boolean()
 });
 function yjsToDocumentationHierarchy(doc) {
   return new FrontendVersionRoomYDoc(doc).getDocumentationHierarchy();
 }
 
 // src/yjs/design-system-content/item-configuration.ts
-import { z as z215 } from "zod";
-var DTODocumentationPageRoomHeaderData = z215.object({
-  title: z215.string(),
+import { z as z216 } from "zod";
+var DTODocumentationPageRoomHeaderData = z216.object({
+  title: z216.string(),
   configuration: DTODocumentationItemConfigurationV2
 });
-var DTODocumentationPageRoomHeaderDataUpdate = z215.object({
-  title: z215.string().optional(),
+var DTODocumentationPageRoomHeaderDataUpdate = z216.object({
+  title: z216.string().optional(),
   configuration: DTODocumentationItemConfigurationV2.omit({ header: true }).extend({ header: DocumentationItemHeaderV2.partial() }).optional()
 });
 function itemConfigurationToYjs(yDoc, item) {
@@ -6381,7 +6414,7 @@ function yjsToItemConfiguration(yDoc) {
     header: rawHeader
   };
   return {
-    title: z215.string().parse(title),
+    title: z216.string().parse(title),
     configuration: DTODocumentationItemConfigurationV2.parse(rawConfig)
   };
 }
@@ -6391,9 +6424,9 @@ var PageBlockEditorModel = PageBlockEditorModelV2;
 var PageSectionEditorModel = PageSectionEditorModelV2;
 
 // src/yjs/docs-editor/model/page.ts
-import { z as z216 } from "zod";
-var DocumentationPageEditorModel = z216.object({
-  blocks: z216.array(DocumentationPageContentItem)
+import { z as z217 } from "zod";
+var DocumentationPageEditorModel = z217.object({
+  blocks: z217.array(DocumentationPageContentItem)
 });
 
 // src/yjs/docs-editor/prosemirror/schema.ts
@@ -10143,7 +10176,7 @@ var blocks = [
 
 // src/yjs/docs-editor/prosemirror-to-blocks.ts
 import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
-import { z as z217 } from "zod";
+import { z as z218 } from "zod";
 function yDocToPage(yDoc, definitions) {
   return yXmlFragmentToPage(yDoc.getXmlFragment("default"), definitions);
 }
@@ -10186,7 +10219,7 @@ function prosemirrorNodeToSectionItem(prosemirrorNode, definitionsMap) {
     return null;
   return {
     id,
-    title: getProsemirrorAttribute(prosemirrorNode, "title", z217.string()) ?? "",
+    title: getProsemirrorAttribute(prosemirrorNode, "title", z218.string()) ?? "",
     columns: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItemColumn").map((c) => prosemirrorNodeToSectionColumns(c, definitionsMap)).filter(nonNullFilter)
   };
 }
@@ -10221,7 +10254,7 @@ function internalProsemirrorNodesToBlocks(prosemirrorNodes, definitionsMap, dept
   });
 }
 function internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap, depth) {
-  const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z217.string());
+  const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z218.string());
   if (!definitionId) {
     console.warn(`definitionId on ${prosemirrorNode.type} is required to be interpreted as a block, skipping node`);
     return [];
@@ -10263,7 +10296,7 @@ function parseAsRichText(prosemirrorNode, definition, property) {
   if (!id)
     return null;
   const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
-  const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z217.string().optional()));
+  const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z218.string().optional()));
   return {
     id,
     type: "Block",
@@ -10389,10 +10422,10 @@ function parseRichTextAttribute(mark) {
   return null;
 }
 function parseProsemirrorLink(mark) {
-  const href = getProsemirrorAttribute(mark, "href", z217.string().optional());
+  const href = getProsemirrorAttribute(mark, "href", z218.string().optional());
   if (!href)
     return null;
-  const target = getProsemirrorAttribute(mark, "target", z217.string().optional());
+  const target = getProsemirrorAttribute(mark, "target", z218.string().optional());
   const openInNewTab = target === "_blank";
   if (href.startsWith("@")) {
     return {
@@ -10415,7 +10448,7 @@ function parseAsTable(prosemirrorNode, definition, property) {
   if (!id)
     return null;
   const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
-  const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z217.boolean().optional()) !== false;
+  const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z218.boolean().optional()) !== false;
   const tableChild = prosemirrorNode.content?.find((c) => c.type === "table");
   if (!tableChild) {
     return emptyTable(id, variantId, 0);
@@ -10462,9 +10495,9 @@ function parseAsTableCell(prosemirrorNode) {
   const id = getProsemirrorBlockId(prosemirrorNode);
   if (!id)
     return null;
-  const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z217.string().optional());
+  const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z218.string().optional());
   let columnWidth;
-  const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z217.array(z217.number()).optional());
+  const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z218.array(z218.number()).optional());
   if (columnWidthArray) {
     columnWidth = roundDimension(columnWidthArray[0]);
   }
@@ -10502,7 +10535,7 @@ function parseAsTableNode(prosemirrorNode) {
         value: parseRichText(prosemirrorNode.content ?? [])
       };
     case "image":
-      const items = getProsemirrorAttribute(prosemirrorNode, "items", z217.string());
+      const items = getProsemirrorAttribute(prosemirrorNode, "items", z218.string());
       if (!items)
         return null;
       const parsedItems = PageBlockItemV2.array().safeParse(JSON.parse(items));
@@ -10619,7 +10652,7 @@ function definitionExpectsPlaceholderItem(definition) {
   );
 }
 function parseBlockItems(prosemirrorNode, definition) {
-  const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z217.string());
+  const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z218.string());
   if (!itemsString)
     return null;
   const itemsJson = JSON.parse(itemsString);
@@ -10631,18 +10664,18 @@ function parseBlockItems(prosemirrorNode, definition) {
 }
 function parseAppearance(prosemirrorNode) {
   let appearance = {};
-  const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z217.string().optional());
+  const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z218.string().optional());
   if (rawAppearanceString) {
     const parsedAppearance = PageBlockAppearanceV2.safeParse(JSON.parse(rawAppearanceString));
     if (parsedAppearance.success) {
       appearance = parsedAppearance.data;
     }
   }
-  const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z217.number().optional());
+  const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z218.number().optional());
   if (columns) {
     appearance.numberOfColumns = columns;
   }
-  const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z217.string().optional());
+  const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z218.string().optional());
   if (backgroundColor) {
     const parsedColor = PageBlockColorV2.safeParse(JSON.parse(backgroundColor));
     if (parsedColor.success) {
@@ -10735,13 +10768,13 @@ function valueSchemaForPropertyType(type) {
   }
 }
 function getProsemirrorBlockId(prosemirrorNode) {
-  const id = getProsemirrorAttribute(prosemirrorNode, "id", z217.string());
+  const id = getProsemirrorAttribute(prosemirrorNode, "id", z218.string());
   if (!id)
     console.warn(`Prosemirror attribute "id" on ${prosemirrorNode.type} is required`);
   return id;
 }
 function getProsemirrorBlockVariantId(prosemirrorNode) {
-  return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z217.string()));
+  return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z218.string()));
 }
 function getProsemirrorAttribute(prosemirrorNode, attributeName, validationSchema) {
   const parsedAttr = validationSchema.safeParse(prosemirrorNode.attrs?.[attributeName]);