@supernova-studio/client 1.72.1 → 1.72.2

package/dist/index.mjs

@@ -7226,25 +7226,6 @@ function zodQueryBoolean() {
 }
 
 // src/api/dto/design-systems/storybook.ts
-var DTOStorybookUploadUrlRequest = z241.object({
-  name: z241.string()
-});
-var DTOStorybookUploadUrlResponse = z241.object({
-  signedUrl: z241.string(),
-  storybookUploadId: z241.string()
-});
-var DTOStorybookAccessTokenResponse = z241.object({
-  accessToken: z241.string()
-});
-var DTOStorybookAccessTokenPayload = z241.object({
-  designSystemId: z241.string(),
-  storybookUploadId: z241.string()
-});
-var DTOStorybookUploadStatus = z241.object({
-  status: z241.enum(["Failed", "InProgress", "Completed", "Unknown"]),
-  timestamp: z241.number().optional(),
-  reason: z241.string().optional()
-});
 var DTOStorybookEntryOrigin = z241.object({
   id: z241.string(),
   type: z241.enum(["story", "docs"]),
@@ -7767,20 +7748,11 @@ var DTOUserDesignSystemsResponse = z255.object({
   workspaces: DTOWorkspace.array()
 });
 
-// src/api/dto/design-systems/version-room.ts
-import { z as z256 } from "zod";
-var DTODesignSystemVersionRoom = z256.object({
-  id: z256.string()
-});
-var DTODesignSystemVersionRoomResponse = z256.object({
-  room: DTODesignSystemVersionRoom
-});
-
 // src/api/dto/design-systems/version.ts
-import { z as z268 } from "zod";
+import { z as z267 } from "zod";
 
 // src/api/payloads/design-systems/update-design-system.ts
-import { z as z257 } from "zod";
+import { z as z256 } from "zod";
 var DTODesignSystemUpdateInput = DesignSystem.partial().omit({
   id: true,
   workspaceId: true,
@@ -7796,59 +7768,59 @@ var DTODesignSystemUpdateInput = DesignSystem.partial().omit({
    */
   designSystemSwitcher: DesignSystemSwitcher.optional()
 });
-var DTODesignSystemUpdateAccessModeInput = z257.object({
+var DTODesignSystemUpdateAccessModeInput = z256.object({
   accessMode: DesignSystemAccessMode,
-  retain: z257.object({
-    userIds: z257.string().array(),
-    inviteIds: z257.string().array()
+  retain: z256.object({
+    userIds: z256.string().array(),
+    inviteIds: z256.string().array()
   }).optional()
 });
-var DTODesignSystemUpdateSwitcherInput = z257.object({
+var DTODesignSystemUpdateSwitcherInput = z256.object({
   designSystemSwitcher: DesignSystemSwitcher
 });
 
 // src/api/payloads/design-systems/version.ts
-import { z as z258 } from "zod";
-var ObjectMeta2 = z258.object({
-  name: z258.string().max(150).optional(),
-  description: z258.string().max(2e3).optional()
+import { z as z257 } from "zod";
+var ObjectMeta2 = z257.object({
+  name: z257.string().max(150).optional(),
+  description: z257.string().max(2e3).optional()
 });
 function validateDesignSystemVersion(version) {
   const urlCompliantRegex = /^[a-zA-Z0-9+.-]+$/;
   return urlCompliantRegex.test(version);
 }
-var DTOCreateVersionInput = z258.object({
+var DTOCreateVersionInput = z257.object({
   meta: ObjectMeta2,
-  version: z258.string().refine(validateDesignSystemVersion, {
+  version: z257.string().refine(validateDesignSystemVersion, {
     message: "Invalid semantic versioning format"
   }),
-  changeLog: z258.string().optional()
+  changeLog: z257.string().optional()
 });
-var DTOUpdateVersionInput = z258.object({
+var DTOUpdateVersionInput = z257.object({
   meta: ObjectMeta2,
-  version: z258.string(),
+  version: z257.string(),
   // required for PUT, but not editable
-  changeLog: z258.string()
+  changeLog: z257.string()
 });
 
 // src/api/payloads/documentation/analytics.ts
-import { z as z259 } from "zod";
-var DTODocumentationAnalyticsTimeFrameComparison = z259.object({
-  referencePeriod: z259.object({
-    start: z259.coerce.date(),
-    end: z259.coerce.date().optional()
+import { z as z258 } from "zod";
+var DTODocumentationAnalyticsTimeFrameComparison = z258.object({
+  referencePeriod: z258.object({
+    start: z258.coerce.date(),
+    end: z258.coerce.date().optional()
   }),
-  baselinePeriod: z259.object({
-    start: z259.coerce.date(),
-    end: z259.coerce.date().optional()
+  baselinePeriod: z258.object({
+    start: z258.coerce.date(),
+    end: z258.coerce.date().optional()
   })
 });
-var DTODocumentationAnalyticsDiffPayload = z259.object({
-  timeFrames: z259.array(DTODocumentationAnalyticsTimeFrameComparison)
+var DTODocumentationAnalyticsDiffPayload = z258.object({
+  timeFrames: z258.array(DTODocumentationAnalyticsTimeFrameComparison)
 });
 
 // src/api/payloads/documentation/block-definitions.ts
-import { z as z260 } from "zod";
+import { z as z259 } from "zod";
 
 // src/api/dto/documentation/block-definition.ts
 var DTOPageBlockDefinitionBehavior = PageBlockDefinitionBehavior;
@@ -7860,79 +7832,79 @@ var DTOPageBlockColorV2 = PageBlockColorV2;
 var DTOPageBlockDefinition = PageBlockDefinition;
 
 // src/api/payloads/documentation/block-definitions.ts
-var DTOGetBlockDefinitionsQuery = z260.object({
+var DTOGetBlockDefinitionsQuery = z259.object({
   files: zodQueryBoolean()
 });
-var DTOGetBlockDefinitionsOutput = z260.object({
-  definitions: z260.array(DTOPageBlockDefinition)
+var DTOGetBlockDefinitionsOutput = z259.object({
+  definitions: z259.array(DTOPageBlockDefinition)
 });
 
 // src/api/payloads/documentation/design-data-doc-diff.ts
-import { z as z261 } from "zod";
-var DTODocumentationPublishTypeQueryParams = z261.object({
-  environment: z261.enum(["Live", "Preview"])
+import { z as z260 } from "zod";
+var DTODocumentationPublishTypeQueryParams = z260.object({
+  environment: z260.enum(["Live", "Preview"])
 });
 
 // src/api/payloads/export/pipeline.ts
-import { z as z263 } from "zod";
+import { z as z262 } from "zod";
 
 // src/api/dto/export/exporter-property.ts
-import { z as z262 } from "zod";
-var PrimitiveValue2 = z262.number().or(z262.boolean()).or(z262.string());
-var ArrayValue2 = z262.array(z262.string());
-var ObjectValue2 = z262.record(z262.string());
+import { z as z261 } from "zod";
+var PrimitiveValue2 = z261.number().or(z261.boolean()).or(z261.string());
+var ArrayValue2 = z261.array(z261.string());
+var ObjectValue2 = z261.record(z261.string());
 var DTOExporterPropertyValue = PrimitiveValue2.or(ArrayValue2).or(ObjectValue2);
-var DTOExporterPropertyType = z262.enum(["Enum", "Boolean", "String", "Number", "Array", "Object", "Code"]);
-var PropertyDefinitionBase2 = z262.object({
-  key: z262.string(),
-  title: z262.string(),
-  description: z262.string(),
-  category: z262.string().optional(),
-  dependsOn: z262.record(z262.boolean()).optional()
-});
-var DTOExporterPropertyDefinitionEnumOption = z262.object({
-  label: z262.string(),
-  description: z262.string()
+var DTOExporterPropertyType = z261.enum(["Enum", "Boolean", "String", "Number", "Array", "Object", "Code"]);
+var PropertyDefinitionBase2 = z261.object({
+  key: z261.string(),
+  title: z261.string(),
+  description: z261.string(),
+  category: z261.string().optional(),
+  dependsOn: z261.record(z261.boolean()).optional()
+});
+var DTOExporterPropertyDefinitionEnumOption = z261.object({
+  label: z261.string(),
+  description: z261.string()
 });
 var DTOExporterPropertyDefinitionEnum = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.Enum),
-  options: z262.record(DTOExporterPropertyDefinitionEnumOption),
-  default: z262.string()
+  type: z261.literal(DTOExporterPropertyType.Enum.Enum),
+  options: z261.record(DTOExporterPropertyDefinitionEnumOption),
+  default: z261.string()
 });
 var DTOExporterPropertyDefinitionBoolean = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.Boolean),
-  default: z262.boolean()
+  type: z261.literal(DTOExporterPropertyType.Enum.Boolean),
+  default: z261.boolean()
 });
 var DTOExporterPropertyDefinitionString = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.String),
-  default: z262.string(),
-  isMultiline: z262.boolean().optional()
+  type: z261.literal(DTOExporterPropertyType.Enum.String),
+  default: z261.string(),
+  isMultiline: z261.boolean().optional()
 });
 var DTOExporterPropertyDefinitionNumber = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.Number),
-  default: z262.number()
+  type: z261.literal(DTOExporterPropertyType.Enum.Number),
+  default: z261.number()
 });
 var DTOExporterPropertyDefinitionArray = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.Array),
+  type: z261.literal(DTOExporterPropertyType.Enum.Array),
   default: ArrayValue2
 });
 var DTOExporterPropertyDefinitionObject = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.Object),
+  type: z261.literal(DTOExporterPropertyType.Enum.Object),
   default: ObjectValue2,
-  allowedKeys: z262.object({
-    options: z262.string().array(),
-    type: z262.string()
+  allowedKeys: z261.object({
+    options: z261.string().array(),
+    type: z261.string()
   }).optional(),
-  allowedValues: z262.object({
-    type: z262.string()
+  allowedValues: z261.object({
+    type: z261.string()
   }).optional()
 });
 var DTOExporterPropertyDefinitionCode = PropertyDefinitionBase2.extend({
-  type: z262.literal(DTOExporterPropertyType.Enum.Code),
-  language: z262.string(),
-  default: z262.string()
+  type: z261.literal(DTOExporterPropertyType.Enum.Code),
+  language: z261.string(),
+  default: z261.string()
 });
-var DTOExporterPropertyDefinition = z262.discriminatedUnion("type", [
+var DTOExporterPropertyDefinition = z261.discriminatedUnion("type", [
   DTOExporterPropertyDefinitionEnum,
   DTOExporterPropertyDefinitionBoolean,
   DTOExporterPropertyDefinitionString,
@@ -7941,89 +7913,89 @@ var DTOExporterPropertyDefinition = z262.discriminatedUnion("type", [
   DTOExporterPropertyDefinitionObject,
   DTOExporterPropertyDefinitionCode
 ]);
-var DTOExporterPropertyDefinitionsResponse = z262.object({
+var DTOExporterPropertyDefinitionsResponse = z261.object({
   properties: DTOExporterPropertyDefinition.array()
 });
-var DTOExporterPropertyValueMap = z262.record(DTOExporterPropertyValue);
+var DTOExporterPropertyValueMap = z261.record(DTOExporterPropertyValue);
 
 // src/api/payloads/export/pipeline.ts
-var GitDestinationOptions = z263.object({
-  branch: z263.string().min(1).nullish(),
-  commitMessage: z263.string().min(1).nullish(),
-  commitAuthorName: z263.string().min(1).nullish(),
-  commitAuthorEmail: z263.string().email().nullish(),
-  pullRequestTitle: z263.string().min(1).nullish(),
-  pullRequestDescription: z263.string().min(1).nullish(),
-  relativePath: z263.string().nullish(),
-  purgeDirectory: z263.boolean().nullish()
-});
-var DTOPipelineCreateBody = z263.object({
-  name: z263.string(),
-  exporterId: z263.string(),
-  designSystemId: z263.string(),
-  isEnabled: z263.boolean(),
+var GitDestinationOptions = z262.object({
+  branch: z262.string().min(1).nullish(),
+  commitMessage: z262.string().min(1).nullish(),
+  commitAuthorName: z262.string().min(1).nullish(),
+  commitAuthorEmail: z262.string().email().nullish(),
+  pullRequestTitle: z262.string().min(1).nullish(),
+  pullRequestDescription: z262.string().min(1).nullish(),
+  relativePath: z262.string().nullish(),
+  purgeDirectory: z262.boolean().nullish()
+});
+var DTOPipelineCreateBody = z262.object({
+  name: z262.string(),
+  exporterId: z262.string(),
+  designSystemId: z262.string(),
+  isEnabled: z262.boolean(),
   eventType: PipelineEventType,
-  brandPersistentId: z263.string().optional(),
-  themePersistentId: z263.string().optional(),
-  themePersistentIds: z263.string().array().optional(),
+  brandPersistentId: z262.string().optional(),
+  themePersistentId: z262.string().optional(),
+  themePersistentIds: z262.string().array().optional(),
   exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
   destination: PipelineDestinationType.optional(),
   gitQuery: GitObjectsQuery,
-  destinations: z263.object({
+  destinations: z262.object({
     s3: ExporterDestinationS3.nullish(),
     azure: ExporterDestinationAzure.nullish(),
     bitbucket: ExporterDestinationBitbucket.nullish(),
     github: ExporterDestinationGithub.nullish(),
     gitlab: ExporterDestinationGitlab.nullish(),
     documentation: ExporterDestinationDocs.nullish(),
-    webhookUrl: z263.string().nullish()
+    webhookUrl: z262.string().nullish()
   })
 });
-var DTOPipelineUpdateBody = z263.object({
-  exporterId: z263.string().optional(),
-  name: z263.string().optional(),
-  isEnabled: z263.boolean().optional(),
+var DTOPipelineUpdateBody = z262.object({
+  exporterId: z262.string().optional(),
+  name: z262.string().optional(),
+  isEnabled: z262.boolean().optional(),
   eventType: PipelineEventType.optional(),
-  brandPersistentId: z263.string().optional(),
-  themePersistentId: z263.string().optional(),
-  themePersistentIds: z263.string().array().optional(),
+  brandPersistentId: z262.string().optional(),
+  themePersistentId: z262.string().optional(),
+  themePersistentIds: z262.string().array().optional(),
   exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
   destination: PipelineDestinationType.optional(),
   gitQuery: GitObjectsQuery.optional(),
-  destinations: z263.object({
+  destinations: z262.object({
     s3: ExporterDestinationS3.nullish(),
     azure: ExporterDestinationAzure.nullish(),
     bitbucket: ExporterDestinationBitbucket.nullish(),
     github: ExporterDestinationGithub.nullish(),
     gitlab: ExporterDestinationGitlab.nullish(),
     documentation: ExporterDestinationDocs.nullish(),
-    webhookUrl: z263.string().nullish()
+    webhookUrl: z262.string().nullish()
   }).optional(),
   gitDestinationOptions: GitDestinationOptions.partial().optional()
 });
-var DTOPipelineTriggerBody = z263.object({
-  designSystemVersionId: z263.string()
+var DTOPipelineTriggerBody = z262.object({
+  designSystemVersionId: z262.string()
 });
 
 // src/api/payloads/liveblocks/auth.ts
-import { z as z264 } from "zod";
-var DTOLiveblocksAuthRequest = z264.object({
-  room: z264.string().optional()
+import { z as z263 } from "zod";
+var DTOLiveblocksAuthRequest = z263.object({
+  room: z263.string().optional()
 });
 
 // src/api/payloads/users/notifications/notification-settings.ts
-import { z as z265 } from "zod";
-var DTOUpdateUserNotificationSettingsPayload = z265.object({
+import { z as z264 } from "zod";
+var DTOUpdateUserNotificationSettingsPayload = z264.object({
   notificationSettings: UserNotificationSettings
 });
-var DTOUserNotificationSettingsResponse = z265.object({
-  userId: z265.string(),
-  workspaceId: z265.string(),
+var DTOUserNotificationSettingsResponse = z264.object({
+  userId: z264.string(),
+  workspaceId: z264.string(),
   notificationSettings: UserNotificationSettings
 });
 
 // src/api/payloads/workspaces/workspace-configuration.ts
-import { z as z266 } from "zod";
+import { z as z265 } from "zod";
 var prohibitedSsoKeys = ["providerId", "metadataXml", "emailDomains"];
 function validateSsoPayload(ssoPayload) {
   const keys = [];
@@ -8046,91 +8018,100 @@ function validateSsoPayload(ssoPayload) {
     keys
   };
 }
-var NpmRegistryInput = z266.object({
-  enabledScopes: z266.array(z266.string()),
-  customRegistryUrl: z266.string().optional(),
-  bypassProxy: z266.boolean().optional(),
-  npmProxyRegistryConfigId: z266.string().optional(),
-  npmProxyVersion: z266.number().optional(),
-  registryType: z266.string(),
-  authType: z266.string(),
-  authHeaderName: z266.string(),
-  authHeaderValue: z266.string(),
-  accessToken: z266.string(),
-  username: z266.string(),
-  password: z266.string()
-});
-var WorkspaceConfigurationPayload = z266.object({
+var NpmRegistryInput = z265.object({
+  enabledScopes: z265.array(z265.string()),
+  customRegistryUrl: z265.string().optional(),
+  bypassProxy: z265.boolean().optional(),
+  npmProxyRegistryConfigId: z265.string().optional(),
+  npmProxyVersion: z265.number().optional(),
+  registryType: z265.string(),
+  authType: z265.string(),
+  authHeaderName: z265.string(),
+  authHeaderValue: z265.string(),
+  accessToken: z265.string(),
+  username: z265.string(),
+  password: z265.string()
+});
+var WorkspaceConfigurationPayload = z265.object({
   ipWhitelist: WorkspaceIpSettings.partial().optional(),
   sso: SsoProvider.partial().optional(),
   npmRegistrySettings: NpmRegistryInput.partial().optional(),
   profile: WorkspaceProfile.partial().optional(),
-  aiFeaturesEnabled: z266.boolean().optional(),
-  projectsEnabled: z266.boolean().optional(),
+  aiFeaturesEnabled: z265.boolean().optional(),
+  projectsEnabled: z265.boolean().optional(),
   defaultProjectAccessMode: WorkspaceDefaultProjectAccessMode.optional(),
   defaultProjectRole: WorkspaceDefaultProjectRole.optional(),
-  aiAskFeaturesEnabled: z266.boolean().optional(),
-  aiCustomInstruction: z266.string().optional()
+  aiAskFeaturesEnabled: z265.boolean().optional(),
+  aiCustomInstruction: z265.string().optional()
 });
 
 // src/api/payloads/workspaces/workspace-integrations.ts
-import { z as z267 } from "zod";
-var DTOWorkspaceIntegrationOauthInput = z267.object({
+import { z as z266 } from "zod";
+var DTOWorkspaceIntegrationOauthInput = z266.object({
   type: IntegrationType
 });
-var DTOWorkspaceIntegrationPATInput = z267.object({
+var DTOWorkspaceIntegrationPATInput = z266.object({
   type: IntegrationType,
   token: IntegrationToken
 });
-var DTOWorkspaceIntegrationGetGitObjectsInput = z267.object({
-  organization: z267.string().optional(),
+var DTOWorkspaceIntegrationGetGitObjectsInput = z266.object({
+  organization: z266.string().optional(),
   // Azure Organization | Bitbucket Workspace slug | Gitlab Group and Sub-Groups | Github Account (User or Organization)
-  project: z267.string().optional(),
+  project: z266.string().optional(),
   // Only for Bitbucket and Azure
-  repository: z267.string().optional(),
+  repository: z266.string().optional(),
   // For all providers. Pay attention for Gitlab, they call repositories "projects".
-  branch: z267.string().optional(),
+  branch: z266.string().optional(),
   // For all providers, useful for PR creations.
-  user: z267.string().optional()
+  user: z266.string().optional()
   // Only for Gitlab User Repositories
 });
 
 // src/api/dto/design-systems/version.ts
-var DTODesignSystemVersion = z268.object({
-  id: z268.string(),
-  createdAt: z268.coerce.date(),
+var DTODesignSystemVersion = z267.object({
+  id: z267.string(),
+  createdAt: z267.coerce.date(),
   meta: ObjectMeta,
-  version: z268.string(),
-  isReadonly: z268.boolean(),
-  changeLog: z268.string(),
-  designSystemId: z268.string()
+  version: z267.string(),
+  isReadonly: z267.boolean(),
+  changeLog: z267.string(),
+  designSystemId: z267.string()
 });
-var DTODesignSystemVersionsListResponse = z268.object({
-  designSystemVersions: z268.array(DTODesignSystemVersion)
+var DTODesignSystemVersionsListResponse = z267.object({
+  designSystemVersions: z267.array(DTODesignSystemVersion)
 });
-var DTODesignSystemVersionGetResponse = z268.object({
+var DTODesignSystemVersionGetResponse = z267.object({
   designSystemVersion: DTODesignSystemVersion
 });
-var DTODesignSystemVersionCreationResponse = z268.object({
+var DTODesignSystemVersionCreationResponse = z267.object({
   meta: ObjectMeta,
-  version: z268.string(),
-  changeLog: z268.string(),
-  isReadOnly: z268.boolean(),
-  designSystemId: z268.string(),
-  jobId: z268.string()
-});
-var VersionSQSPayload = z268.object({
-  jobId: z268.string(),
-  designSystemId: z268.string(),
+  version: z267.string(),
+  changeLog: z267.string(),
+  isReadOnly: z267.boolean(),
+  designSystemId: z267.string(),
+  jobId: z267.string()
+});
+var VersionSQSPayload = z267.object({
+  jobId: z267.string(),
+  designSystemId: z267.string(),
   input: DTOCreateVersionInput
 });
-var DTODesignSystemVersionJobsResponse = z268.object({
-  jobs: z268.array(VersionCreationJob)
+var DTODesignSystemVersionJobsResponse = z267.object({
+  jobs: z267.array(VersionCreationJob)
 });
-var DTODesignSystemVersionJobStatusResponse = z268.object({
+var DTODesignSystemVersionJobStatusResponse = z267.object({
   job: VersionCreationJob
 });
 
+// src/api/dto/design-systems/version-room.ts
+import { z as z268 } from "zod";
+var DTODesignSystemVersionRoom = z268.object({
+  id: z268.string()
+});
+var DTODesignSystemVersionRoomResponse = z268.object({
+  room: DTODesignSystemVersionRoom
+});
+
 // src/api/dto/design-systems/view.ts
 import { z as z269 } from "zod";
 var DTOElementViewColumnSharedAttributes = z269.object({
@@ -11409,53 +11390,89 @@ var DTOSandboxTemplateBuildFinalizeResponse = z345.object({
   ok: z345.boolean()
 });
 
-// src/api/dto/themes/override.ts
+// src/api/dto/storybook-sites/index.ts
 import { z as z346 } from "zod";
+var DTOStorybookUploadStatus = z346.enum(["PendingUpload", "Failed", "InProgress", "Completed", "Timeout"]);
+var DTOStorybookSiteVersion = z346.object({
+  id: z346.string(),
+  isPublic: z346.boolean(),
+  createdAt: z346.string(),
+  uploadStatus: DTOStorybookUploadStatus
+});
+var DTOStorybookSite = z346.object({
+  id: z346.string(),
+  designSystemId: z346.string(),
+  name: z346.string(),
+  indexPageUrl: z346.string(),
+  createdAt: z346.string(),
+  currentVersion: DTOStorybookSiteVersion
+});
+var DTOStorybookSiteListQuery = z346.object({
+  designSystemId: z346.string()
+});
+var DTOStorybookSiteListResponse = z346.object({
+  sites: DTOStorybookSite.array()
+});
+var DTOStorybookSiteUploadPayload = z346.object({
+  designSystemId: z346.string(),
+  isPublic: z346.boolean(),
+  name: z346.string()
+});
+var DTOStorybookSiteUploadResponse = z346.object({
+  storybookSiteVersion: DTOStorybookSiteVersion,
+  uploadUrl: z346.string()
+});
+var DTOStorybookSiteVersionResponse = z346.object({
+  storybookSiteVersion: DTOStorybookSiteVersion
+});
+
+// src/api/dto/themes/override.ts
+import { z as z347 } from "zod";
 var DTOThemeOverride = DesignTokenTypedData.and(
-  z346.object({
-    tokenPersistentId: z346.string(),
+  z347.object({
+    tokenPersistentId: z347.string(),
     origin: ThemeOverrideOrigin.optional()
   })
 );
 var DTOThemeOverrideCreatePayload = DesignTokenTypedData.and(
-  z346.object({
-    tokenPersistentId: z346.string()
+  z347.object({
+    tokenPersistentId: z347.string()
   })
 );
 
 // src/api/dto/themes/theme.ts
-import { z as z347 } from "zod";
-var DTOThemesListQuery = z347.object({
-  brandId: z347.string().optional()
-});
-var DTOTheme = z347.object({
-  id: z347.string(),
-  persistentId: z347.string(),
-  designSystemVersionId: z347.string(),
-  brandId: z347.string(),
+import { z as z348 } from "zod";
+var DTOThemesListQuery = z348.object({
+  brandId: z348.string().optional()
+});
+var DTOTheme = z348.object({
+  id: z348.string(),
+  persistentId: z348.string(),
+  designSystemVersionId: z348.string(),
+  brandId: z348.string(),
   meta: ObjectMeta,
-  codeName: z347.string(),
-  parentPersistentId: z347.string().optional(),
-  collectionPersistentIds: z347.string().array(),
+  codeName: z348.string(),
+  parentPersistentId: z348.string().optional(),
+  collectionPersistentIds: z348.string().array(),
   overrides: DTOThemeOverride.array()
 });
-var DTOThemeResponse = z347.object({
+var DTOThemeResponse = z348.object({
   theme: DTOTheme
 });
-var DTOThemeListResponse = z347.object({
+var DTOThemeListResponse = z348.object({
   themes: DTOTheme.array()
 });
-var DTOThemeCreatePayload = z347.object({
+var DTOThemeCreatePayload = z348.object({
   meta: ObjectMeta,
-  persistentId: z347.string(),
-  brandId: z347.string(),
-  codeName: z347.string(),
+  persistentId: z348.string(),
+  brandId: z348.string(),
+  codeName: z348.string(),
   overrides: DTOThemeOverride.array()
 });
 
 // src/api/dto/trail-events/trail-events.ts
-import { z as z348 } from "zod";
-var DTOTrailEventType = z348.enum([
+import { z as z349 } from "zod";
+var DTOTrailEventType = z349.enum([
   "IterationCreated",
   "IterationBookmarked",
   "FeatureCreated",
@@ -11473,124 +11490,124 @@ var DTOTrailEventType = z348.enum([
   "FeaturePublished",
   "FeatureUnpublished"
 ]);
-var DTOTrailEventBase = z348.object({
-  id: z348.string(),
-  projectId: z348.string(),
-  userId: z348.string(),
-  createdAt: z348.coerce.date(),
-  updatedAt: z348.coerce.date()
-});
-var DTOTrailEventIterationCreatedPayload = z348.object({
-  iterationName: z348.string(),
-  iterationId: z348.string().uuid(),
-  featureId: z348.string().uuid()
-});
-var DTOTrailEventIterationBookmarkedPayload = z348.object({
-  iterationId: z348.string().uuid(),
-  featureId: z348.string().uuid(),
-  iterationName: z348.string()
-});
-var DTOTrailEventIterationPromotedPayload = z348.object({
-  iterationId: z348.string().uuid(),
-  featureId: z348.string().uuid(),
-  iterationName: z348.string()
-});
-var DTOTrailEventFeatureCreatedPayload = z348.object({
-  featureId: z348.string().uuid(),
-  name: z348.string(),
-  description: z348.string().optional()
-});
-var DTOTrailEventFeatureDeletedPayload = z348.object({
-  featureId: z348.string().uuid(),
-  name: z348.string()
-});
-var DTOTrailEventFeatureArchivedPayload = z348.object({
-  featureId: z348.string().uuid(),
-  name: z348.string()
-});
-var DTOTrailEventDocumentCreatedPayload = z348.object({
-  documentId: z348.string().uuid(),
-  title: z348.string(),
-  sectionId: z348.string().uuid().optional()
-});
-var DTOTrailEventDocumentDeletedPayload = z348.object({
-  documentId: z348.string().uuid(),
-  title: z348.string()
-});
-var DTOTrailEventDocumentUpdatedPayload = z348.object({
-  documentId: z348.string().uuid(),
-  title: z348.string(),
-  sectionId: z348.string().uuid().optional()
-});
-var DTOTrailEventDocumentCommentSentPayload = z348.object({
-  documentId: z348.string().uuid(),
-  title: z348.string(),
-  sectionId: z348.string().uuid().optional()
-});
-var DTOTrailEventProjectCreatedPayload = z348.object({
-  name: z348.string(),
-  description: z348.string().optional()
-});
-var DTOTrailEventFeaturePublishedPayload = z348.object({
-  featureId: z348.string().uuid(),
-  featureName: z348.string(),
-  iterationId: z348.string().uuid().nullish(),
-  iterationName: z348.string().nullish()
-});
-var DTOTrailEventFeatureUnpublishedPayload = z348.object({
-  featureId: z348.string().uuid(),
-  featureName: z348.string(),
-  iterationId: z348.string().uuid().nullish(),
-  iterationName: z348.string().nullish()
-});
-var DTOTrailEventProjectArchivedPayload = z348.object({
-  name: z348.string()
-});
-var DTOTrailEventProjectContextCreatedPayload = z348.object({
-  contextId: z348.number(),
-  name: z348.string(),
-  description: z348.string().optional()
-});
-var DTOTrailEventProjectContextArchivedPayload = z348.object({
-  contextId: z348.number()
-});
-var DTOTrailEventPayload = z348.discriminatedUnion("type", [
-  z348.object({ type: z348.literal("IterationCreated"), payload: DTOTrailEventIterationCreatedPayload }),
-  z348.object({ type: z348.literal("IterationBookmarked"), payload: DTOTrailEventIterationBookmarkedPayload }),
-  z348.object({ type: z348.literal("FeatureCreated"), payload: DTOTrailEventFeatureCreatedPayload }),
-  z348.object({ type: z348.literal("FeatureDeleted"), payload: DTOTrailEventFeatureDeletedPayload }),
-  z348.object({ type: z348.literal("FeatureArchived"), payload: DTOTrailEventFeatureArchivedPayload }),
-  z348.object({ type: z348.literal("DocumentCreated"), payload: DTOTrailEventDocumentCreatedPayload }),
-  z348.object({ type: z348.literal("DocumentDeleted"), payload: DTOTrailEventDocumentDeletedPayload }),
-  z348.object({ type: z348.literal("DocumentUpdated"), payload: DTOTrailEventDocumentUpdatedPayload }),
-  z348.object({ type: z348.literal("DocumentCommentSent"), payload: DTOTrailEventDocumentCommentSentPayload }),
-  z348.object({ type: z348.literal("ProjectCreated"), payload: DTOTrailEventProjectCreatedPayload }),
-  z348.object({ type: z348.literal("ProjectArchived"), payload: DTOTrailEventProjectArchivedPayload }),
-  z348.object({ type: z348.literal("IterationPromoted"), payload: DTOTrailEventIterationPromotedPayload }),
-  z348.object({ type: z348.literal("ProjectContextCreated"), payload: DTOTrailEventProjectContextCreatedPayload }),
-  z348.object({ type: z348.literal("ProjectContextArchived"), payload: DTOTrailEventProjectContextArchivedPayload }),
-  z348.object({ type: z348.literal("FeaturePublished"), payload: DTOTrailEventFeaturePublishedPayload }),
-  z348.object({ type: z348.literal("FeatureUnpublished"), payload: DTOTrailEventFeatureUnpublishedPayload })
+var DTOTrailEventBase = z349.object({
+  id: z349.string(),
+  projectId: z349.string(),
+  userId: z349.string(),
+  createdAt: z349.coerce.date(),
+  updatedAt: z349.coerce.date()
+});
+var DTOTrailEventIterationCreatedPayload = z349.object({
+  iterationName: z349.string(),
+  iterationId: z349.string().uuid(),
+  featureId: z349.string().uuid()
+});
+var DTOTrailEventIterationBookmarkedPayload = z349.object({
+  iterationId: z349.string().uuid(),
+  featureId: z349.string().uuid(),
+  iterationName: z349.string()
+});
+var DTOTrailEventIterationPromotedPayload = z349.object({
+  iterationId: z349.string().uuid(),
+  featureId: z349.string().uuid(),
+  iterationName: z349.string()
+});
+var DTOTrailEventFeatureCreatedPayload = z349.object({
+  featureId: z349.string().uuid(),
+  name: z349.string(),
+  description: z349.string().optional()
+});
+var DTOTrailEventFeatureDeletedPayload = z349.object({
+  featureId: z349.string().uuid(),
+  name: z349.string()
+});
+var DTOTrailEventFeatureArchivedPayload = z349.object({
+  featureId: z349.string().uuid(),
+  name: z349.string()
+});
+var DTOTrailEventDocumentCreatedPayload = z349.object({
+  documentId: z349.string().uuid(),
+  title: z349.string(),
+  sectionId: z349.string().uuid().optional()
+});
+var DTOTrailEventDocumentDeletedPayload = z349.object({
+  documentId: z349.string().uuid(),
+  title: z349.string()
+});
+var DTOTrailEventDocumentUpdatedPayload = z349.object({
+  documentId: z349.string().uuid(),
+  title: z349.string(),
+  sectionId: z349.string().uuid().optional()
+});
+var DTOTrailEventDocumentCommentSentPayload = z349.object({
+  documentId: z349.string().uuid(),
+  title: z349.string(),
+  sectionId: z349.string().uuid().optional()
+});
+var DTOTrailEventProjectCreatedPayload = z349.object({
+  name: z349.string(),
+  description: z349.string().optional()
+});
+var DTOTrailEventFeaturePublishedPayload = z349.object({
+  featureId: z349.string().uuid(),
+  featureName: z349.string(),
+  iterationId: z349.string().uuid().nullish(),
+  iterationName: z349.string().nullish()
+});
+var DTOTrailEventFeatureUnpublishedPayload = z349.object({
+  featureId: z349.string().uuid(),
+  featureName: z349.string(),
+  iterationId: z349.string().uuid().nullish(),
+  iterationName: z349.string().nullish()
+});
+var DTOTrailEventProjectArchivedPayload = z349.object({
+  name: z349.string()
+});
+var DTOTrailEventProjectContextCreatedPayload = z349.object({
+  contextId: z349.number(),
+  name: z349.string(),
+  description: z349.string().optional()
+});
+var DTOTrailEventProjectContextArchivedPayload = z349.object({
+  contextId: z349.number()
+});
+var DTOTrailEventPayload = z349.discriminatedUnion("type", [
+  z349.object({ type: z349.literal("IterationCreated"), payload: DTOTrailEventIterationCreatedPayload }),
+  z349.object({ type: z349.literal("IterationBookmarked"), payload: DTOTrailEventIterationBookmarkedPayload }),
+  z349.object({ type: z349.literal("FeatureCreated"), payload: DTOTrailEventFeatureCreatedPayload }),
+  z349.object({ type: z349.literal("FeatureDeleted"), payload: DTOTrailEventFeatureDeletedPayload }),
+  z349.object({ type: z349.literal("FeatureArchived"), payload: DTOTrailEventFeatureArchivedPayload }),
+  z349.object({ type: z349.literal("DocumentCreated"), payload: DTOTrailEventDocumentCreatedPayload }),
+  z349.object({ type: z349.literal("DocumentDeleted"), payload: DTOTrailEventDocumentDeletedPayload }),
+  z349.object({ type: z349.literal("DocumentUpdated"), payload: DTOTrailEventDocumentUpdatedPayload }),
+  z349.object({ type: z349.literal("DocumentCommentSent"), payload: DTOTrailEventDocumentCommentSentPayload }),
+  z349.object({ type: z349.literal("ProjectCreated"), payload: DTOTrailEventProjectCreatedPayload }),
+  z349.object({ type: z349.literal("ProjectArchived"), payload: DTOTrailEventProjectArchivedPayload }),
+  z349.object({ type: z349.literal("IterationPromoted"), payload: DTOTrailEventIterationPromotedPayload }),
+  z349.object({ type: z349.literal("ProjectContextCreated"), payload: DTOTrailEventProjectContextCreatedPayload }),
+  z349.object({ type: z349.literal("ProjectContextArchived"), payload: DTOTrailEventProjectContextArchivedPayload }),
+  z349.object({ type: z349.literal("FeaturePublished"), payload: DTOTrailEventFeaturePublishedPayload }),
+  z349.object({ type: z349.literal("FeatureUnpublished"), payload: DTOTrailEventFeatureUnpublishedPayload })
 ]);
 var DTOTrailEvent = DTOTrailEventPayload.and(DTOTrailEventBase);
 var DTOTrailEventWithDetails = DTOTrailEvent.and(
-  z348.object({
-    projectName: z348.string().optional(),
-    userName: z348.string().optional()
+  z349.object({
+    projectName: z349.string().optional(),
+    userName: z349.string().optional()
   })
 );
-var DTOTrailEventListInput = z348.object({
-  projectId: z348.string()
+var DTOTrailEventListInput = z349.object({
+  projectId: z349.string()
 });
-var DTOTrailEventListResponse = z348.object({
-  events: z348.array(DTOTrailEventWithDetails)
+var DTOTrailEventListResponse = z349.object({
+  events: z349.array(DTOTrailEventWithDetails)
 });
 var DTOTrailEventCreate = DTOTrailEventPayload.and(
   DTOTrailEventBase.omit({ id: true, createdAt: true, updatedAt: true })
 );
-var DTOTrailEventClientCreate = z348.discriminatedUnion("type", [
-  z348.object({ type: z348.literal("DocumentUpdated"), payload: DTOTrailEventDocumentUpdatedPayload }),
-  z348.object({ type: z348.literal("DocumentCommentSent"), payload: DTOTrailEventDocumentCommentSentPayload })
+var DTOTrailEventClientCreate = z349.discriminatedUnion("type", [
+  z349.object({ type: z349.literal("DocumentUpdated"), payload: DTOTrailEventDocumentUpdatedPayload }),
+  z349.object({ type: z349.literal("DocumentCommentSent"), payload: DTOTrailEventDocumentCommentSentPayload })
 ]).and(DTOTrailEventBase.omit({ id: true, createdAt: true, updatedAt: true }));
 
 // src/api/endpoints/codegen/exporters.ts
@@ -11635,13 +11652,13 @@ var ExportersEndpoint = class {
 };
 
 // src/api/endpoints/codegen/jobs.ts
-import { z as z349 } from "zod";
+import { z as z350 } from "zod";
 var ExporterJobsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
   }
   list(workspaceId) {
-    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/jobs`, z349.any());
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/jobs`, z350.any());
   }
   get(workspaceId, jobId) {
     return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/jobs/${jobId}`, DTOExportJobResponseLegacy);
@@ -11698,168 +11715,391 @@ var CodegenEndpoint = class {
   }
 };
 
-// src/api/endpoints/design-system/versions/brands.ts
-import { z as z350 } from "zod";
-var BrandsEndpoint = class {
+// src/api/endpoints/design-system/analytics.ts
+var DesignSystemAnalyticsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
   }
-  get(designSystemId, versionId, brandId) {
-    return this.requestExecutor.json(
-      `/design-systems/${designSystemId}/versions/${versionId}/brands/${brandId}`,
-      DTOBrandGetResponse
-    );
-  }
-  list(designSystemId, versionId) {
-    return this.requestExecutor.json(
-      `/design-systems/${designSystemId}/versions/${versionId}/brands`,
-      DTOBrandsListResponse
-    );
-  }
-  create(designSystemId, versionId, body) {
+  get(designSystemId, versionId, body) {
     return this.requestExecutor.json(
-      `/design-systems/${designSystemId}/versions/${versionId}/brands`,
-      DTOBrandGetResponse,
-      {
-        method: "POST",
-        body
-      }
+      `/design-systems/${designSystemId}/versions/${versionId}/documentation/analytics`,
+      DTODocumentationPageAnalyticsResponse,
+      { method: "POST", body }
     );
   }
-  update(dsId, vId, brandId, body) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/brands/${brandId}`, DTOBrandGetResponse, {
-      method: "PUT",
-      body
-    });
+};
+
+// src/api/endpoints/design-system/bff.ts
+var DesignSystemBffEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
   }
-  delete(dsId, vId, brandId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/brands/${brandId}`, z350.any(), {
-      method: "DELETE"
+  import(dsId, payload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/bff/import`, DTOImportJobResponse, {
+      method: "POST",
+      body: payload
     });
   }
 };
 
-// src/api/endpoints/design-system/versions/code-components.ts
-var CodeComponentsEndpoint = class {
+// src/api/endpoints/design-system/contact.ts
+var DesignSystemContactsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
   }
-  async import(dsId, vId, body) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/code-components`,
-      DTOCodeComponentUpsertResponse,
-      {
-        body,
-        method: "POST"
-      }
-    );
+  list(dsId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/contacts`, DTODesignSystemContactsResponse, {
+      method: "GET"
+    });
   }
-  async list(dsId, vId, brandId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/code-components`,
-      DTOCodeComponentListResponse,
-      { query: new URLSearchParams(pickDefined({ brandId })) }
-    );
+};
+
+// src/api/endpoints/design-system/design-systems.ts
+import { z as z357 } from "zod";
+
+// src/api/endpoints/design-system/figma-node-structures.ts
+var FigmaNodeStructuresEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
   }
-  async deleteAll(dsId, vId) {
+  list(dsId) {
     return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/code-components`,
-      DTOCodeComponentListResponse,
-      {
-        method: "DELETE"
-      }
+      `/design-systems/${dsId}/figma-node-structures`,
+      DTOFigmaNodeStructureListResponse
     );
   }
-  async analyzePackage(dsId, vId, body) {
+  get(dsId, structureId) {
     return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/code-components/analyze-package`,
-      DTOAnalyzeCodeComponentsInPackageResponse,
-      {
-        body,
-        method: "POST"
-      }
+      `/design-systems/${dsId}/figma-node-structures/${structureId}`,
+      DTOFigmaNodeStructureDetailResponse
     );
   }
 };
 
-// src/api/endpoints/design-system/versions/documentation.ts
-var DocumentationEndpoint = class {
+// src/api/endpoints/design-system/members.ts
+var DesignSystemMembersEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
   }
-  async getStructure(designSystemId, versionId) {
-    return await this.requestExecutor.json(
-      `/design-systems/${designSystemId}/versions/${versionId}/documentation/structure`,
-      DTODocumentationStructure
-    );
-  }
-  async getDocStructure(dsId, vId) {
-    return await this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/documentation/structure`,
-      DTODocumentationStructure
-    );
-  }
-  async getPageRoom(dsId, vId, pageId) {
-    return await this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/documentation/pages/${pageId}/room`,
-      DTODocumentationPageRoomResponse
-    );
-  }
-  async getBlockDefinitions(dsId, vId) {
-    return await this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/documentation/block-definitions`,
-      DTOGetBlockDefinitionsOutput
-    );
-  }
-  async publish(dsId, vId, body) {
-    return await this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/documentation/publish`,
-      DTOPublishDocumentationResponse,
-      {
-        method: "POST",
-        body
-      }
-    );
+  list(dsId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/members`, DTODesignSystemMemberListResponse, {
+      method: "GET"
+    });
   }
-  documentationPageContent(dsId, versionId, pageId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${versionId}/documentation/pages/${pageId}/content`,
-      DTODocumentationPageContentGetResponse
-    );
+  update(dsId, body) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/members`, DTODesignSystemMembersUpdateResponse, {
+      method: "POST",
+      body
+    });
   }
 };
 
-// src/api/endpoints/design-system/versions/ds-components.ts
-var DesignSystemComponentEndpoint = class {
+// src/api/endpoints/design-system/redirects.ts
+var DesignSystemPageRedirectsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
   }
-  async list(dsId, vId, brandId) {
+  create(dsId, body) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/documentation/redirects`, DTOPageRedirectResponse, {
+      body,
+      method: "POST"
+    });
+  }
+  list(dsId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/documentation/redirects`, DTOPageRedirectListResponse, {
+      method: "GET"
+    });
+  }
+  update(dsId, redirectId, body) {
     return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/design-system-components`,
-      DTODesignSystemComponentListResponse,
-      { query: new URLSearchParams(pickDefined({ brandId })) }
+      `/design-systems/${dsId}/documentation/redirects/${redirectId}`,
+      DTOPageRedirectResponse,
+      {
+        body,
+        method: "PUT"
+      }
     );
   }
-  async create(dsId, vId, body) {
+  delete(dsId, redirectId) {
     return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/design-system-components`,
-      DTODesignSystemComponentResponse,
+      `/design-systems/${dsId}/documentation/redirects/${redirectId}`,
+      DTOPageRedirectDeleteResponse,
       {
-        body,
-        method: "POST"
+        method: "DELETE"
       }
     );
   }
 };
 
-// src/api/endpoints/design-system/versions/elements-action.ts
-var ElementsActionEndpoint = class {
+// src/api/endpoints/design-system/sources.ts
+import { z as z351 } from "zod";
+var DesignSystemSourcesEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
   }
-  async createDocPage(dsId, vId, input) {
-    return this.action(dsId, vId, { type: "DocumentationPageCreate", input });
+  create(dsId, payload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourceResponse, {
+      method: "POST",
+      body: payload
+    });
+  }
+  list(dsId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourcesListResponse);
+  }
+  get(dsId, sourceId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, DTODataSourceResponse);
+  }
+  delete(dsId, sourceId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, z351.any(), { method: "DELETE" });
+  }
+  updateFigmaSource(dsId, sourceId, payload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, DTODataSourceResponse, {
+      method: "PUT",
+      body: payload
+    });
+  }
+  updateStorybookSource(dsId, sourceId, payload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, DTODataSourceResponse, {
+      method: "PUT",
+      body: payload
+    });
+  }
+  figmaImport(dsId, payload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/cloud-import`, DTOImportJobResponse, {
+      method: "POST",
+      body: payload
+    });
+  }
+  storybookImport(dsId, payload) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/head/storybook-import`,
+      DTODataSourcesStorybookResponse,
+      {
+        method: "POST",
+        body: payload
+      }
+    );
+  }
+  updateStorybookImport(dsId, versionId, payload) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${versionId}/storybook-import`,
+      DTODataSourcesStorybookResponse,
+      {
+        method: "POST",
+        body: payload
+      }
+    );
+  }
+};
+
+// src/api/endpoints/design-system/storybook.ts
+import { z as z352 } from "zod";
+var StorybookEntriesEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  list(dsId, query = {}) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/storybook`, DTOStorybookEntryListResponse, {
+      query: new URLSearchParams(pickDefined(query))
+    });
+  }
+  replace(dsId, entryId) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/head/storybook/${entryId}`,
+      DTOStorybookEntryReplaceAction,
+      { method: "PUT" }
+    );
+  }
+  delete(dsId, entryId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/storybook/${entryId}`, z352.any(), {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/api/endpoints/design-system/versions/brands.ts
+import { z as z353 } from "zod";
+var BrandsEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  get(designSystemId, versionId, brandId) {
+    return this.requestExecutor.json(
+      `/design-systems/${designSystemId}/versions/${versionId}/brands/${brandId}`,
+      DTOBrandGetResponse
+    );
+  }
+  list(designSystemId, versionId) {
+    return this.requestExecutor.json(
+      `/design-systems/${designSystemId}/versions/${versionId}/brands`,
+      DTOBrandsListResponse
+    );
+  }
+  create(designSystemId, versionId, body) {
+    return this.requestExecutor.json(
+      `/design-systems/${designSystemId}/versions/${versionId}/brands`,
+      DTOBrandGetResponse,
+      {
+        method: "POST",
+        body
+      }
+    );
+  }
+  update(dsId, vId, brandId, body) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/brands/${brandId}`, DTOBrandGetResponse, {
+      method: "PUT",
+      body
+    });
+  }
+  delete(dsId, vId, brandId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/brands/${brandId}`, z353.any(), {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/api/endpoints/design-system/versions/code-components.ts
+var CodeComponentsEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  async import(dsId, vId, body) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/code-components`,
+      DTOCodeComponentUpsertResponse,
+      {
+        body,
+        method: "POST"
+      }
+    );
+  }
+  async list(dsId, vId, brandId) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/code-components`,
+      DTOCodeComponentListResponse,
+      { query: new URLSearchParams(pickDefined({ brandId })) }
+    );
+  }
+  async deleteAll(dsId, vId) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/code-components`,
+      DTOCodeComponentListResponse,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async analyzePackage(dsId, vId, body) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/code-components/analyze-package`,
+      DTOAnalyzeCodeComponentsInPackageResponse,
+      {
+        body,
+        method: "POST"
+      }
+    );
+  }
+};
+
+// src/api/endpoints/design-system/versions/documentation.ts
+var DocumentationEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  async getStructure(designSystemId, versionId) {
+    return await this.requestExecutor.json(
+      `/design-systems/${designSystemId}/versions/${versionId}/documentation/structure`,
+      DTODocumentationStructure
+    );
+  }
+  async getDocStructure(dsId, vId) {
+    return await this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/documentation/structure`,
+      DTODocumentationStructure
+    );
+  }
+  async getPageRoom(dsId, vId, pageId) {
+    return await this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/documentation/pages/${pageId}/room`,
+      DTODocumentationPageRoomResponse
+    );
+  }
+  async getBlockDefinitions(dsId, vId) {
+    return await this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/documentation/block-definitions`,
+      DTOGetBlockDefinitionsOutput
+    );
+  }
+  async publish(dsId, vId, body) {
+    return await this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/documentation/publish`,
+      DTOPublishDocumentationResponse,
+      {
+        method: "POST",
+        body
+      }
+    );
+  }
+  documentationPageContent(dsId, versionId, pageId) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${versionId}/documentation/pages/${pageId}/content`,
+      DTODocumentationPageContentGetResponse
+    );
+  }
+};
+
+// src/api/endpoints/design-system/versions/ds-components.ts
+var DesignSystemComponentEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  async list(dsId, vId, brandId) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/design-system-components`,
+      DTODesignSystemComponentListResponse,
+      { query: new URLSearchParams(pickDefined({ brandId })) }
+    );
+  }
+  async create(dsId, vId, body) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/design-system-components`,
+      DTODesignSystemComponentResponse,
+      {
+        body,
+        method: "POST"
+      }
+    );
+  }
+};
+
+// src/api/endpoints/design-system/versions/elements.ts
+var ElementsEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  getElementsV1(dsId, vId, query) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/elements`, DTOElementsGetOutput, {
+      query: serializeQuery(query)
+    });
+  }
+  getElementsV2(dsId, vId, query) {
+    const fullQuery = {
+      ...query,
+      responseVersion: 2
+    };
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/elements`, DTOElementsGetOutputV2, {
+      query: serializeQuery(fullQuery)
+    });
+  }
+};
+
+// src/api/endpoints/design-system/versions/elements-action.ts
+var ElementsActionEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  async createDocPage(dsId, vId, input) {
+    return this.action(dsId, vId, { type: "DocumentationPageCreate", input });
   }
   async createDocGroup(dsId, vId, input) {
     return this.action(dsId, vId, { type: "DocumentationGroupCreate", input });
@@ -11900,27 +12140,6 @@ var ElementsActionEndpoint = class {
   }
 };
 
-// src/api/endpoints/design-system/versions/elements.ts
-var ElementsEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  getElementsV1(dsId, vId, query) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/elements`, DTOElementsGetOutput, {
-      query: serializeQuery(query)
-    });
-  }
-  getElementsV2(dsId, vId, query) {
-    const fullQuery = {
-      ...query,
-      responseVersion: 2
-    };
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/elements`, DTOElementsGetOutputV2, {
-      query: serializeQuery(fullQuery)
-    });
-  }
-};
-
 // src/api/endpoints/design-system/versions/figma-component-groups.ts
 var FigmaComponentGroupsEndpoint = class {
   constructor(requestExecutor) {
@@ -12008,26 +12227,8 @@ var ImportJobsEndpoint = class {
   }
 };
 
-// src/api/endpoints/design-system/versions/overrides.ts
-import { z as z351 } from "zod";
-var OverridesEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  create(dsId, versionId, themeId, body) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${versionId}/themes/${themeId}/overrides`,
-      z351.any(),
-      {
-        method: "POST",
-        body
-      }
-    );
-  }
-};
-
 // src/api/endpoints/design-system/versions/property-definitions.ts
-import { z as z352 } from "zod";
+import { z as z354 } from "zod";
 var ElementPropertyDefinitionsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -12055,7 +12256,7 @@ var ElementPropertyDefinitionsEndpoint = class {
   delete(designSystemId, versionId, defId) {
     return this.requestExecutor.json(
       `/design-systems/${designSystemId}/versions/${versionId}/element-properties/definitions/${defId}`,
-      z352.any(),
+      z354.any(),
       { method: "DELETE" }
     );
   }
@@ -12094,7 +12295,27 @@ var VersionStatsEndpoint = class {
 };
 
 // src/api/endpoints/design-system/versions/themes.ts
-import { z as z353 } from "zod";
+import { z as z356 } from "zod";
+
+// src/api/endpoints/design-system/versions/overrides.ts
+import { z as z355 } from "zod";
+var OverridesEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  create(dsId, versionId, themeId, body) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${versionId}/themes/${themeId}/overrides`,
+      z355.any(),
+      {
+        method: "POST",
+        body
+      }
+    );
+  }
+};
+
+// src/api/endpoints/design-system/versions/themes.ts
 var ThemesEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -12117,7 +12338,7 @@ var ThemesEndpoint = class {
     });
   }
   delete(dsId, versionId, themeId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${versionId}/themes/${themeId}`, z353.any(), {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${versionId}/themes/${themeId}`, z356.any(), {
       method: "DELETE"
     });
   }
@@ -12200,289 +12421,52 @@ var DesignSystemVersionsEndpoint = class {
     __publicField(this, "figmaComponentGroups");
     __publicField(this, "figmaFrameStructures");
     __publicField(this, "stats");
-    __publicField(this, "elementPropertyDefinitions");
-    __publicField(this, "elementPropertyValues");
-    __publicField(this, "elementsAction");
-    __publicField(this, "elements");
-    __publicField(this, "designSystemComponents");
-    __publicField(this, "documentation");
-    __publicField(this, "codeComponents");
-    __publicField(this, "files");
-    this.themes = new ThemesEndpoint(requestExecutor);
-    this.brands = new BrandsEndpoint(requestExecutor);
-    this.tokenCollections = new TokenCollectionsEndpoint(requestExecutor);
-    this.importJobs = new ImportJobsEndpoint(requestExecutor);
-    this.tokens = new TokensEndpoint(requestExecutor);
-    this.tokenGroups = new TokenGroupsEndpoint(requestExecutor);
-    this.figmaComponents = new FigmaComponentsEndpoint(requestExecutor);
-    this.figmaComponentGroups = new FigmaComponentGroupsEndpoint(requestExecutor);
-    this.figmaFrameStructures = new FigmaFrameStructuresEndpoint(requestExecutor);
-    this.stats = new VersionStatsEndpoint(requestExecutor);
-    this.elementPropertyDefinitions = new ElementPropertyDefinitionsEndpoint(requestExecutor);
-    this.elementPropertyValues = new ElementPropertyValuesEndpoint(requestExecutor);
-    this.elementsAction = new ElementsActionEndpoint(requestExecutor);
-    this.elements = new ElementsEndpoint(requestExecutor);
-    this.designSystemComponents = new DesignSystemComponentEndpoint(requestExecutor);
-    this.documentation = new DocumentationEndpoint(requestExecutor);
-    this.codeComponents = new CodeComponentsEndpoint(requestExecutor);
-    this.files = new DesignSystemFilesEndpoint(requestExecutor);
-  }
-  list(dsId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions`, DTODesignSystemVersionsListResponse);
-  }
-  commit(dsId, body) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/head/commit`, DTODesignSystemVersionCreationResponse, {
-      method: "POST",
-      body
-    });
-  }
-  job(dsId, jobId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/jobs/${jobId}`,
-      DTODesignSystemVersionJobStatusResponse
-    );
-  }
-  room(dsId, vId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/room`,
-      DTODesignSystemVersionRoomResponse
-    );
-  }
-};
-
-// src/api/endpoints/design-system/analytics.ts
-var DesignSystemAnalyticsEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  get(designSystemId, versionId, body) {
-    return this.requestExecutor.json(
-      `/design-systems/${designSystemId}/versions/${versionId}/documentation/analytics`,
-      DTODocumentationPageAnalyticsResponse,
-      { method: "POST", body }
-    );
-  }
-};
-
-// src/api/endpoints/design-system/bff.ts
-var DesignSystemBffEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  import(dsId, payload) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/bff/import`, DTOImportJobResponse, {
-      method: "POST",
-      body: payload
-    });
-  }
-};
-
-// src/api/endpoints/design-system/contact.ts
-var DesignSystemContactsEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  list(dsId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/contacts`, DTODesignSystemContactsResponse, {
-      method: "GET"
-    });
-  }
-};
-
-// src/api/endpoints/design-system/design-systems.ts
-import { z as z357 } from "zod";
-
-// src/api/endpoints/design-system/figma-node-structures.ts
-var FigmaNodeStructuresEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  list(dsId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/figma-node-structures`,
-      DTOFigmaNodeStructureListResponse
-    );
-  }
-  get(dsId, structureId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/figma-node-structures/${structureId}`,
-      DTOFigmaNodeStructureDetailResponse
-    );
-  }
-};
-
-// src/api/endpoints/design-system/members.ts
-var DesignSystemMembersEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  list(dsId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/members`, DTODesignSystemMemberListResponse, {
-      method: "GET"
-    });
-  }
-  update(dsId, body) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/members`, DTODesignSystemMembersUpdateResponse, {
-      method: "POST",
-      body
-    });
-  }
-};
-
-// src/api/endpoints/design-system/redirects.ts
-var DesignSystemPageRedirectsEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  create(dsId, body) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/documentation/redirects`, DTOPageRedirectResponse, {
-      body,
-      method: "POST"
-    });
-  }
-  list(dsId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/documentation/redirects`, DTOPageRedirectListResponse, {
-      method: "GET"
-    });
-  }
-  update(dsId, redirectId, body) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/documentation/redirects/${redirectId}`,
-      DTOPageRedirectResponse,
-      {
-        body,
-        method: "PUT"
-      }
-    );
-  }
-  delete(dsId, redirectId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/documentation/redirects/${redirectId}`,
-      DTOPageRedirectDeleteResponse,
-      {
-        method: "DELETE"
-      }
-    );
-  }
-};
-
-// src/api/endpoints/design-system/sources.ts
-import { z as z354 } from "zod";
-var DesignSystemSourcesEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  create(dsId, payload) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourceResponse, {
-      method: "POST",
-      body: payload
-    });
-  }
-  list(dsId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourcesListResponse);
-  }
-  get(dsId, sourceId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, DTODataSourceResponse);
-  }
-  delete(dsId, sourceId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, z354.any(), { method: "DELETE" });
-  }
-  updateFigmaSource(dsId, sourceId, payload) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, DTODataSourceResponse, {
-      method: "PUT",
-      body: payload
-    });
-  }
-  updateStorybookSource(dsId, sourceId, payload) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, DTODataSourceResponse, {
-      method: "PUT",
-      body: payload
-    });
-  }
-  figmaImport(dsId, payload) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/cloud-import`, DTOImportJobResponse, {
-      method: "POST",
-      body: payload
-    });
-  }
-  storybookImport(dsId, payload) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/head/storybook-import`,
-      DTODataSourcesStorybookResponse,
-      {
-        method: "POST",
-        body: payload
-      }
-    );
-  }
-  updateStorybookImport(dsId, versionId, payload) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${versionId}/storybook-import`,
-      DTODataSourcesStorybookResponse,
-      {
-        method: "POST",
-        body: payload
-      }
-    );
-  }
-};
-
-// src/api/endpoints/design-system/storybook.ts
-import { z as z355 } from "zod";
-var StorybookEntriesEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  list(dsId, query = {}) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/storybook`, DTOStorybookEntryListResponse, {
-      query: new URLSearchParams(pickDefined(query))
-    });
-  }
-  replace(dsId, entryId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/head/storybook/${entryId}`,
-      DTOStorybookEntryReplaceAction,
-      { method: "PUT" }
-    );
-  }
-  delete(dsId, entryId) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/storybook/${entryId}`, z355.any(), {
-      method: "DELETE"
-    });
+    __publicField(this, "elementPropertyDefinitions");
+    __publicField(this, "elementPropertyValues");
+    __publicField(this, "elementsAction");
+    __publicField(this, "elements");
+    __publicField(this, "designSystemComponents");
+    __publicField(this, "documentation");
+    __publicField(this, "codeComponents");
+    __publicField(this, "files");
+    this.themes = new ThemesEndpoint(requestExecutor);
+    this.brands = new BrandsEndpoint(requestExecutor);
+    this.tokenCollections = new TokenCollectionsEndpoint(requestExecutor);
+    this.importJobs = new ImportJobsEndpoint(requestExecutor);
+    this.tokens = new TokensEndpoint(requestExecutor);
+    this.tokenGroups = new TokenGroupsEndpoint(requestExecutor);
+    this.figmaComponents = new FigmaComponentsEndpoint(requestExecutor);
+    this.figmaComponentGroups = new FigmaComponentGroupsEndpoint(requestExecutor);
+    this.figmaFrameStructures = new FigmaFrameStructuresEndpoint(requestExecutor);
+    this.stats = new VersionStatsEndpoint(requestExecutor);
+    this.elementPropertyDefinitions = new ElementPropertyDefinitionsEndpoint(requestExecutor);
+    this.elementPropertyValues = new ElementPropertyValuesEndpoint(requestExecutor);
+    this.elementsAction = new ElementsActionEndpoint(requestExecutor);
+    this.elements = new ElementsEndpoint(requestExecutor);
+    this.designSystemComponents = new DesignSystemComponentEndpoint(requestExecutor);
+    this.documentation = new DocumentationEndpoint(requestExecutor);
+    this.codeComponents = new CodeComponentsEndpoint(requestExecutor);
+    this.files = new DesignSystemFilesEndpoint(requestExecutor);
   }
-};
-
-// src/api/endpoints/design-system/storybook-hosting.ts
-import { z as z356 } from "zod";
-var StorybookHostingEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
+  list(dsId) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions`, DTODesignSystemVersionsListResponse);
   }
-  getSignedUploadUrl(dsId, body) {
-    return this.requestExecutor.json(`/design-systems/${dsId}/storybook/upload`, DTOStorybookUploadUrlResponse, {
-      body,
-      method: "POST"
+  commit(dsId, body) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/head/commit`, DTODesignSystemVersionCreationResponse, {
+      method: "POST",
+      body
     });
   }
-  delete(dsId, storybookUploadId) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/storybook/${storybookUploadId}`,
-      z356.object({ ok: z356.boolean() }),
-      {
-        method: "DELETE"
-      }
-    );
-  }
-  getUploadStatus(dsId, storybookUploadId) {
+  job(dsId, jobId) {
     return this.requestExecutor.json(
-      `/design-systems/${dsId}/storybook/${storybookUploadId}/status`,
-      DTOStorybookUploadStatus
+      `/design-systems/${dsId}/versions/jobs/${jobId}`,
+      DTODesignSystemVersionJobStatusResponse
     );
   }
-  getAccessToken(dsId, name) {
+  room(dsId, vId) {
     return this.requestExecutor.json(
-      `/design-systems/${dsId}/storybook/alias/${name}/access-token`,
-      DTOStorybookAccessTokenResponse
+      `/design-systems/${dsId}/versions/${vId}/room`,
+      DTODesignSystemVersionRoomResponse
     );
   }
 };
@@ -12496,7 +12480,6 @@ var DesignSystemsEndpoint = class {
     __publicField(this, "bff");
     __publicField(this, "sources");
     __publicField(this, "storybook");
-    __publicField(this, "storybookHosting");
     __publicField(this, "contacts");
     __publicField(this, "redirects");
     __publicField(this, "figmaNodeStructures");
@@ -12506,7 +12489,6 @@ var DesignSystemsEndpoint = class {
     this.bff = new DesignSystemBffEndpoint(requestExecutor);
     this.sources = new DesignSystemSourcesEndpoint(requestExecutor);
     this.storybook = new StorybookEntriesEndpoint(requestExecutor);
-    this.storybookHosting = new StorybookHostingEndpoint(requestExecutor);
     this.contacts = new DesignSystemContactsEndpoint(requestExecutor);
     this.redirects = new DesignSystemPageRedirectsEndpoint(requestExecutor);
     this.figmaNodeStructures = new FigmaNodeStructuresEndpoint(requestExecutor);
@@ -12547,6 +12529,25 @@ var DesignSystemsEndpoint = class {
   }
 };
 
+// src/api/endpoints/files.ts
+var FilesEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  upload(body) {
+    return this.requestExecutor.json(`/files/upload`, DTOFileUploadBulkResponse, {
+      method: "POST",
+      body
+    });
+  }
+  finalizeUpload(body) {
+    return this.requestExecutor.json(`/files/upload/finalize`, DTOFileFinalizeBulkResponse, {
+      method: "POST",
+      body
+    });
+  }
+};
+
 // src/api/endpoints/forge/agents.ts
 var ForgeAgentsEndpoint = class {
   constructor(requestExecutor) {
@@ -13122,6 +13123,19 @@ var ForgeProjectIterationsEndpoint = class {
   }
 };
 
+// src/api/endpoints/liveblocks.ts
+var LiveblocksEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  auth(body) {
+    return this.requestExecutor.json("/liveblocks/auth", DTOLiveblocksAuthResponse, {
+      method: "POST",
+      body
+    });
+  }
+};
+
 // src/api/endpoints/mcp/streams.ts
 var MCPStreamsEndpoint = class {
   constructor(requestExecutor) {
@@ -13188,6 +13202,88 @@ var SandboxesEndpoint = class {
   }
 };
 
+// src/api/endpoints/storybook-sites.ts
+import z359 from "zod";
+var StorybookSitesEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  listSites(query) {
+    return this.requestExecutor.json(`/storybook/sites`, DTOStorybookSiteListResponse, {
+      query: new URLSearchParams(query)
+    });
+  }
+  deleteSite(siteId) {
+    return this.requestExecutor.json(`/storybook/sites/${siteId}`, z359.unknown(), {
+      method: "DELETE"
+    });
+  }
+  uploadInit(body) {
+    return this.requestExecutor.json(`/storybook/site-versions`, DTOStorybookSiteUploadResponse, {
+      body,
+      method: "POST"
+    });
+  }
+  getVersion(siteVersionId) {
+    return this.requestExecutor.json(`/storybook/site-versions/${siteVersionId}`, DTOStorybookSiteVersionResponse);
+  }
+  uploadFinailize(siteVersionId) {
+    return this.requestExecutor.json(`/storybook/site-versions/${siteVersionId}`, DTOStorybookSiteVersionResponse, {
+      method: "PUT"
+    });
+  }
+};
+
+// src/api/endpoints/threads.ts
+var ThreadsEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  listMessages(threadId) {
+    return this.requestExecutor.json(`/threads/${threadId}/messages`, DTOThreadMessageListResponse);
+  }
+  postMessage(threadId, body) {
+    return this.requestExecutor.json(`/threads/${threadId}/messages`, DTOThreadMessageListResponse, {
+      method: "POST",
+      body
+    });
+  }
+  postReaction(threadId, body) {
+    return this.requestExecutor.json(`/threads/${threadId}/reactions`, DTOThreadReactionResponse, {
+      method: "POST",
+      body
+    });
+  }
+  deleteReaction(threadId, body) {
+    return this.requestExecutor.json(`/threads/${threadId}/reactions`, DTOFileUploadFinalizeResponse, {
+      method: "DELETE",
+      body
+    });
+  }
+};
+
+// src/api/endpoints/users.ts
+var UsersEndpoint = class {
+  constructor(requestExecutor) {
+    this.requestExecutor = requestExecutor;
+  }
+  getMe() {
+    return this.requestExecutor.json("/users/me", DTOAuthenticatedUserResponse);
+  }
+  listWorkspaces(uid) {
+    return this.requestExecutor.json(`/users/${uid}/workspaces`, DTOUserWorkspaceMembershipsResponse);
+  }
+  delete(uid) {
+    return this.requestExecutor.json(`/users/${uid}`, DTOAuthenticatedUserResponse, { method: "DELETE" });
+  }
+  updateProfile(uid, body) {
+    return this.requestExecutor.json(`/users/${uid}/profile`, DTOAuthenticatedUserResponse, {
+      method: "PUT",
+      body
+    });
+  }
+};
+
 // src/api/endpoints/workspaces/billing.ts
 var WorkspaceBillingEndpoint = class {
   constructor(requestExecutor) {
@@ -13208,7 +13304,7 @@ var WorkspaceBillingEndpoint = class {
 };
 
 // src/api/endpoints/workspaces/chat-threads.ts
-import { z as z359 } from "zod";
+import { z as z360 } from "zod";
 var WorkspaceChatThreadsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -13240,7 +13336,7 @@ var WorkspaceChatThreadsEndpoint = class {
     );
   }
   delete(workspaceId, threadId) {
-    return this.requestExecutor.json(`/workspaces/${workspaceId}/forge/threads/${threadId}`, z359.any(), {
+    return this.requestExecutor.json(`/workspaces/${workspaceId}/forge/threads/${threadId}`, z360.any(), {
       method: "DELETE"
     });
   }
@@ -13272,7 +13368,7 @@ var ChatThreadMessagesEndpoint = class {
     );
   }
   score(workspaceId, threadId, body) {
-    return this.requestExecutor.json(`/workspaces/${workspaceId}/forge/threads/${threadId}/scores`, z359.any(), {
+    return this.requestExecutor.json(`/workspaces/${workspaceId}/forge/threads/${threadId}/scores`, z360.any(), {
       method: "POST",
       body
     });
@@ -13280,7 +13376,7 @@ var ChatThreadMessagesEndpoint = class {
 };
 
 // src/api/endpoints/workspaces/integrations.ts
-import { z as z360 } from "zod";
+import { z as z361 } from "zod";
 var WorkspaceIntegrationsEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -13289,7 +13385,7 @@ var WorkspaceIntegrationsEndpoint = class {
     return this.requestExecutor.json(`/workspaces/${wsId}/integrations`, DTOIntegrationsGetListResponse);
   }
   delete(wsId, iId) {
-    return this.requestExecutor.json(`/workspaces/${wsId}/integrations/${iId}`, z360.unknown(), { method: "DELETE" });
+    return this.requestExecutor.json(`/workspaces/${wsId}/integrations/${iId}`, z361.unknown(), { method: "DELETE" });
   }
 };
 
@@ -13321,7 +13417,7 @@ var WorkspaceInvitationsEndpoint = class {
 };
 
 // src/api/endpoints/workspaces/members.ts
-import { z as z361 } from "zod";
+import { z as z362 } from "zod";
 var WorkspaceMembersEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -13338,7 +13434,7 @@ var WorkspaceMembersEndpoint = class {
     });
   }
   invite(workspaceId, body) {
-    return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z361.any(), { method: "POST", body });
+    return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z362.any(), { method: "POST", body });
   }
   delete(workspaceId, userId) {
     return this.requestExecutor.json(`/workspaces/${workspaceId}/members/${userId}`, DTOWorkspaceResponse, {
@@ -13367,7 +13463,7 @@ var WorkspaceNpmRegistryEndpoint = class {
 };
 
 // src/api/endpoints/workspaces/subscription.ts
-import { z as z362 } from "zod";
+import { z as z363 } from "zod";
 var WorkspaceSubscriptionEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -13378,7 +13474,7 @@ var WorkspaceSubscriptionEndpoint = class {
     });
   }
   update(workspaceId, body) {
-    return this.requestExecutor.json(`/workspaces/${workspaceId}/subscription`, z362.any(), {
+    return this.requestExecutor.json(`/workspaces/${workspaceId}/subscription`, z363.any(), {
       method: "PUT",
       body
     });
@@ -13396,7 +13492,7 @@ var WorkspaceSubscriptionEndpoint = class {
 };
 
 // src/api/endpoints/workspaces/workspaces.ts
-import { z as z363 } from "zod";
+import { z as z364 } from "zod";
 var WorkspacesEndpoint = class {
   constructor(requestExecutor) {
     this.requestExecutor = requestExecutor;
@@ -13432,7 +13528,7 @@ var WorkspacesEndpoint = class {
     return this.requestExecutor.json(`/workspaces/${workspaceId}`, DTOWorkspaceResponse, { method: "GET" });
   }
   delete(workspaceId) {
-    return this.requestExecutor.json(`/workspaces/${workspaceId}`, z363.any(), { method: "DELETE" });
+    return this.requestExecutor.json(`/workspaces/${workspaceId}`, z364.any(), { method: "DELETE" });
   }
   getPortalSettings(workspaceId) {
     return this.requestExecutor.json(`/workspaces/${workspaceId}/portal/settings`, DTOPortalSettingsGetResponse, {
@@ -13453,88 +13549,6 @@ var WorkspacesEndpoint = class {
   }
 };
 
-// src/api/endpoints/files.ts
-var FilesEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  upload(body) {
-    return this.requestExecutor.json(`/files/upload`, DTOFileUploadBulkResponse, {
-      method: "POST",
-      body
-    });
-  }
-  finalizeUpload(body) {
-    return this.requestExecutor.json(`/files/upload/finalize`, DTOFileFinalizeBulkResponse, {
-      method: "POST",
-      body
-    });
-  }
-};
-
-// src/api/endpoints/liveblocks.ts
-var LiveblocksEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  auth(body) {
-    return this.requestExecutor.json("/liveblocks/auth", DTOLiveblocksAuthResponse, {
-      method: "POST",
-      body
-    });
-  }
-};
-
-// src/api/endpoints/threads.ts
-var ThreadsEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  listMessages(threadId) {
-    return this.requestExecutor.json(`/threads/${threadId}/messages`, DTOThreadMessageListResponse);
-  }
-  postMessage(threadId, body) {
-    return this.requestExecutor.json(`/threads/${threadId}/messages`, DTOThreadMessageListResponse, {
-      method: "POST",
-      body
-    });
-  }
-  postReaction(threadId, body) {
-    return this.requestExecutor.json(`/threads/${threadId}/reactions`, DTOThreadReactionResponse, {
-      method: "POST",
-      body
-    });
-  }
-  deleteReaction(threadId, body) {
-    return this.requestExecutor.json(`/threads/${threadId}/reactions`, DTOFileUploadFinalizeResponse, {
-      method: "DELETE",
-      body
-    });
-  }
-};
-
-// src/api/endpoints/users.ts
-var UsersEndpoint = class {
-  constructor(requestExecutor) {
-    this.requestExecutor = requestExecutor;
-  }
-  getMe() {
-    return this.requestExecutor.json("/users/me", DTOAuthenticatedUserResponse);
-  }
-  listWorkspaces(uid) {
-    return this.requestExecutor.json(`/users/${uid}/workspaces`, DTOUserWorkspaceMembershipsResponse);
-  }
-  delete(uid) {
-    return this.requestExecutor.json(`/users/${uid}`, DTOAuthenticatedUserResponse, { method: "DELETE" });
-  }
-  updateProfile(uid, body) {
-    return this.requestExecutor.json(`/users/${uid}/profile`, DTOAuthenticatedUserResponse, {
-      method: "PUT",
-      body
-    });
-  }
-};
-
 // src/api/transport/request-executor-error.ts
 var RequestExecutorError = class _RequestExecutorError extends Error {
   constructor(type, message, errorCode, serverErrorType, cause) {
@@ -13583,9 +13597,9 @@ ${bodyText}`,
 
 // src/api/transport/request-executor.ts
 import fetch from "node-fetch";
-import { z as z364 } from "zod";
-var ResponseWrapper = z364.object({
-  result: z364.record(z364.any())
+import { z as z365 } from "zod";
+var ResponseWrapper = z365.object({
+  result: z365.record(z365.any())
 });
 var RequestExecutor = class {
   constructor(testServerConfig) {
@@ -13655,6 +13669,7 @@ var SupernovaApiClient = class {
     __publicField(this, "threads");
     __publicField(this, "mcpStreams");
     __publicField(this, "sandboxes");
+    __publicField(this, "storybookSites");
     const apiSecret = config.apiSecret ?? process?.env?.SUPERNOVA_API_SECRET;
     const requestExecutor = new RequestExecutor({
       apiSecret,
@@ -13671,29 +13686,30 @@ var SupernovaApiClient = class {
     this.threads = new ThreadsEndpoint(requestExecutor);
     this.mcpStreams = new MCPStreamsEndpoint(requestExecutor);
     this.sandboxes = new SandboxesEndpoint(requestExecutor);
+    this.storybookSites = new StorybookSitesEndpoint(requestExecutor);
   }
 };
 
 // src/events/design-system.ts
-import { z as z365 } from "zod";
-var DTOEventFigmaNodesRendered = z365.object({
-  type: z365.literal("DesignSystem.FigmaNodesRendered"),
-  designSystemId: z365.string(),
-  versionId: z365.string(),
-  figmaNodePersistentIds: z365.string().array()
-});
-var DTOEventDataSourcesImported = z365.object({
-  type: z365.literal("DesignSystem.ImportJobFinished"),
-  designSystemId: z365.string(),
-  versionId: z365.string(),
-  importJobId: z365.string(),
+import { z as z366 } from "zod";
+var DTOEventFigmaNodesRendered = z366.object({
+  type: z366.literal("DesignSystem.FigmaNodesRendered"),
+  designSystemId: z366.string(),
+  versionId: z366.string(),
+  figmaNodePersistentIds: z366.string().array()
+});
+var DTOEventDataSourcesImported = z366.object({
+  type: z366.literal("DesignSystem.ImportJobFinished"),
+  designSystemId: z366.string(),
+  versionId: z366.string(),
+  importJobId: z366.string(),
   dataSourceType: DataSourceRemoteType,
-  dataSourceIds: z365.string().array()
+  dataSourceIds: z366.string().array()
 });
 
 // src/events/event.ts
-import { z as z366 } from "zod";
-var DTOEvent = z366.discriminatedUnion("type", [DTOEventDataSourcesImported, DTOEventFigmaNodesRendered]);
+import { z as z367 } from "zod";
+var DTOEvent = z367.discriminatedUnion("type", [DTOEventDataSourcesImported, DTOEventFigmaNodesRendered]);
 
 // src/sync/docs-local-action-executor.ts
 function applyActionsLocally(input) {
@@ -13989,7 +14005,7 @@ var LocalDocsElementActionExecutor = class {
 import PQueue from "p-queue";
 
 // src/yjs/design-system-content/documentation-hierarchy.ts
-import { z as z367 } from "zod";
+import { z as z368 } from "zod";
 
 // src/yjs/version-room/base.ts
 var VersionRoomBaseYDoc = class {
@@ -14539,24 +14555,24 @@ var FrontendVersionRoomYDoc = class {
 };
 
 // src/yjs/design-system-content/documentation-hierarchy.ts
-var DocumentationHierarchySettings = z367.object({
-  routingVersion: z367.string(),
-  isDraftFeatureAdopted: z367.boolean(),
-  isApprovalFeatureEnabled: z367.boolean(),
-  approvalRequiredForPublishing: z367.boolean()
+var DocumentationHierarchySettings = z368.object({
+  routingVersion: z368.string(),
+  isDraftFeatureAdopted: z368.boolean(),
+  isApprovalFeatureEnabled: z368.boolean(),
+  approvalRequiredForPublishing: z368.boolean()
 });
 function yjsToDocumentationHierarchy(doc) {
   return new FrontendVersionRoomYDoc(doc).getDocumentationHierarchy();
 }
 
 // src/yjs/design-system-content/item-configuration.ts
-import { z as z368 } from "zod";
-var DTODocumentationPageRoomHeaderData = z368.object({
-  title: z368.string(),
+import { z as z369 } from "zod";
+var DTODocumentationPageRoomHeaderData = z369.object({
+  title: z369.string(),
   configuration: DTODocumentationItemConfigurationV2
 });
-var DTODocumentationPageRoomHeaderDataUpdate = z368.object({
-  title: z368.string().optional(),
+var DTODocumentationPageRoomHeaderDataUpdate = z369.object({
+  title: z369.string().optional(),
   configuration: DTODocumentationItemConfigurationV2.omit({ header: true }).extend({ header: DocumentationItemHeaderV2.partial() }).optional()
 });
 function itemConfigurationToYjs(yDoc, item) {
@@ -14591,9 +14607,9 @@ var PageBlockEditorModel = PageBlockEditorModelV2;
 var PageSectionEditorModel = PageSectionEditorModelV2;
 
 // src/yjs/docs-editor/model/page.ts
-import { z as z369 } from "zod";
-var DocumentationPageEditorModel = z369.object({
-  blocks: z369.array(DocumentationPageContentItem)
+import { z as z370 } from "zod";
+var DocumentationPageEditorModel = z370.object({
+  blocks: z370.array(DocumentationPageContentItem)
 });
 
 // src/yjs/docs-editor/prosemirror/inner-editor-schema.ts
@@ -18270,7 +18286,7 @@ var blocks = [
 
 // src/yjs/docs-editor/prosemirror-to-blocks.ts
 import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
-import { z as z370 } from "zod";
+import { z as z371 } from "zod";
 function yDocToPage(yDoc, definitions) {
   return yXmlFragmentToPage(yDoc.getXmlFragment("default"), definitions);
 }
@@ -18346,7 +18362,7 @@ function prosemirrorNodeToSectionItem(prosemirrorNode, definitionsMap) {
   if (!id) return null;
   return {
     id,
-    title: getProsemirrorAttribute(prosemirrorNode, "title", z370.string()) ?? "",
+    title: getProsemirrorAttribute(prosemirrorNode, "title", z371.string()) ?? "",
     columns: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItemColumn").map((c) => prosemirrorNodeToSectionColumns(c, definitionsMap)).filter(nonNullFilter)
   };
 }
@@ -18380,7 +18396,7 @@ function internalProsemirrorNodesToBlocks(prosemirrorNodes, definitionsMap, dept
   });
 }
 function internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap, depth) {
-  const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z370.string());
+  const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z371.string());
   if (!definitionId) {
     console.warn(`definitionId on ${prosemirrorNode.type} is required to be interpreted as a block, skipping node`);
     return [];
@@ -18421,7 +18437,7 @@ function parseAsRichText(prosemirrorNode, definition, property) {
   const id = getProsemirrorBlockId(prosemirrorNode);
   if (!id) return null;
   const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
-  const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z370.string().optional()));
+  const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z371.string().optional()));
   return {
     id,
     type: "Block",
@@ -18544,9 +18560,9 @@ function parseRichTextAttribute(mark) {
   return null;
 }
 function parseProsemirrorLink(mark) {
-  const href = getProsemirrorAttribute(mark, "href", z370.string().optional());
+  const href = getProsemirrorAttribute(mark, "href", z371.string().optional());
   if (!href) return null;
-  const target = getProsemirrorAttribute(mark, "target", z370.string().optional());
+  const target = getProsemirrorAttribute(mark, "target", z371.string().optional());
   const openInNewTab = target === "_blank";
   if (href.startsWith("@")) {
     return {
@@ -18565,9 +18581,9 @@ function parseProsemirrorLink(mark) {
   }
 }
 function parseProsemirrorCommentHighlight(mark) {
-  const highlightId = getProsemirrorAttribute(mark, "highlightId", z370.string().optional());
+  const highlightId = getProsemirrorAttribute(mark, "highlightId", z371.string().optional());
   if (!highlightId) return null;
-  const isResolved = getProsemirrorAttribute(mark, "resolved", z370.boolean().optional()) ?? false;
+  const isResolved = getProsemirrorAttribute(mark, "resolved", z371.boolean().optional()) ?? false;
   return {
     type: "Comment",
     commentHighlightId: highlightId,
@@ -18578,7 +18594,7 @@ function parseAsTable(prosemirrorNode, definition, property) {
   const id = getProsemirrorBlockId(prosemirrorNode);
   if (!id) return null;
   const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
-  const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z370.boolean().optional()) !== false;
+  const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z371.boolean().optional()) !== false;
   const tableChild = prosemirrorNode.content?.find((c) => c.type === "table");
   if (!tableChild) {
     return emptyTable(id, variantId, 0);
@@ -18624,9 +18640,9 @@ function parseAsTable(prosemirrorNode, definition, property) {
 function parseAsTableCell(prosemirrorNode) {
   const id = getProsemirrorBlockId(prosemirrorNode);
   if (!id) return null;
-  const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z370.string().optional());
+  const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z371.string().optional());
   let columnWidth;
-  const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z370.array(z370.number()).nullish());
+  const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z371.array(z371.number()).nullish());
   if (columnWidthArray) {
     columnWidth = roundDimension(columnWidthArray[0]);
   }
@@ -18662,7 +18678,7 @@ function parseAsTableNode(prosemirrorNode) {
         value: parseRichText(prosemirrorNode.content ?? [])
       };
     case "image":
-      const items = getProsemirrorAttribute(prosemirrorNode, "items", z370.string());
+      const items = getProsemirrorAttribute(prosemirrorNode, "items", z371.string());
       if (!items) return null;
       const parsedItems = PageBlockItemV2.array().safeParse(JSON.parse(items));
       if (!parsedItems.success) return null;
@@ -18776,7 +18792,7 @@ function definitionExpectsPlaceholderItem(definition) {
   );
 }
 function parseBlockItems(prosemirrorNode, definition) {
-  const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z370.string());
+  const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z371.string());
   if (!itemsString) return null;
   const itemsJson = JSON.parse(itemsString);
   if (!Array.isArray(itemsJson)) {
@@ -18787,18 +18803,18 @@ function parseBlockItems(prosemirrorNode, definition) {
 }
 function parseAppearance(prosemirrorNode) {
   let appearance = {};
-  const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z370.string().optional());
+  const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z371.string().optional());
   if (rawAppearanceString) {
     const parsedAppearance = PageBlockAppearanceV2.safeParse(JSON.parse(rawAppearanceString));
     if (parsedAppearance.success) {
       appearance = parsedAppearance.data;
     }
   }
-  const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z370.number().optional());
+  const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z371.number().optional());
   if (columns) {
     appearance.numberOfColumns = columns;
   }
-  const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z370.string().optional());
+  const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z371.string().optional());
   if (backgroundColor) {
     const parsedColor = PageBlockColorV2.safeParse(JSON.parse(backgroundColor));
     if (parsedColor.success) {
@@ -18899,12 +18915,12 @@ function valueSchemaForPropertyType(type) {
   }
 }
 function getProsemirrorBlockId(prosemirrorNode) {
-  const id = getProsemirrorAttribute(prosemirrorNode, "id", z370.string());
+  const id = getProsemirrorAttribute(prosemirrorNode, "id", z371.string());
   if (!id) console.warn(`Prosemirror attribute "id" on ${prosemirrorNode.type} is required`);
   return id;
 }
 function getProsemirrorBlockVariantId(prosemirrorNode) {
-  return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z370.string()));
+  return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z371.string()));
 }
 function getProsemirrorAttribute(prosemirrorNode, attributeName, validationSchema) {
   const parsedAttr = validationSchema.safeParse(prosemirrorNode.attrs?.[attributeName]);
@@ -20744,8 +20760,6 @@ export {
   DTOSandboxTemplateVersion,
   DTOSandboxTemplateVersionCreated,
   DTOSandboxTemplateVersionDetail,
-  DTOStorybookAccessTokenPayload,
-  DTOStorybookAccessTokenResponse,
   DTOStorybookEntry,
   DTOStorybookEntryListResponse,
   DTOStorybookEntryOrigin,
@@ -20753,10 +20767,15 @@ export {
   DTOStorybookEntryReplaceAction,
   DTOStorybookEntryResponse,
   DTOStorybookImportPayload,
+  DTOStorybookSite,
+  DTOStorybookSiteListQuery,
+  DTOStorybookSiteListResponse,
+  DTOStorybookSiteUploadPayload,
+  DTOStorybookSiteUploadResponse,
+  DTOStorybookSiteVersion,
+  DTOStorybookSiteVersionResponse,
   DTOStorybookSourceUpdatePayload,
   DTOStorybookUploadStatus,
-  DTOStorybookUploadUrlRequest,
-  DTOStorybookUploadUrlResponse,
   DTOSubscription,
   DTOSubscriptionResponse,
   DTOSubscriptionUpcomingChange,
@@ -20952,7 +20971,7 @@ export {
   SandboxTemplatesEndpoint,
   SandboxesEndpoint,
   StorybookEntriesEndpoint,
-  StorybookHostingEndpoint,
+  StorybookSitesEndpoint,
   StringVariableScopeType,
   SupernovaApiClient,
   ThemesEndpoint,