@supernova-studio/client 0.45.0 → 0.45.1

package/dist/index.mjs

@@ -1,92 +1,3 @@
-// src/api/conversion/design-system/version-to-dto.ts
-function designSystemVersionToDto(version) {
-  return {
-    id: version.id,
-    designSystemId: version.designSystemId,
-    createdAt: version.createdAt,
-    meta: {
-      name: version.name,
-      description: version.comment
-    },
-    version: version.version,
-    changeLog: version.changeLog,
-    isReadonly: version.isReadonly
-  };
-}
-
-// src/api/conversion/design-systems/elements/properties/property-definition.ts
-function elementPropertyDefinitionToDto(elementProperyDefinition) {
-  return {
-    id: elementProperyDefinition.id,
-    designSystemVersionId: elementProperyDefinition.designSystemVersionId,
-    meta: {
-      name: elementProperyDefinition.name,
-      description: elementProperyDefinition.description
-    },
-    persistentId: elementProperyDefinition.persistentId,
-    type: elementProperyDefinition.type,
-    targetElementType: elementProperyDefinition.targetElementType,
-    codeName: elementProperyDefinition.codeName,
-    options: elementProperyDefinition.options,
-    linkElementType: elementProperyDefinition.linkElementType
-  };
-}
-
-// src/api/conversion/design-systems/elements/properties/property-value.ts
-function elementPropertyValueToDto(elementPropertyValue) {
-  let value;
-  let valuePreview;
-  if (elementPropertyValue.stringValue) {
-    value = elementPropertyValue.stringValue;
-  } else if (elementPropertyValue.numberValue) {
-    value = elementPropertyValue.numberValue;
-  } else if (typeof elementPropertyValue.booleanValue === "boolean") {
-    value = elementPropertyValue.booleanValue;
-  } else if (elementPropertyValue.referenceValue) {
-    value = elementPropertyValue.referenceValue;
-    valuePreview = elementPropertyValue.referenceValuePreview;
-  } else {
-    value = void 0;
-  }
-  return {
-    id: elementPropertyValue.id,
-    designSystemVersionId: elementPropertyValue.designSystemVersionId,
-    definitionId: elementPropertyValue.definitionPersistentId,
-    targetElementId: elementPropertyValue.targetElementPersistentId,
-    value,
-    valuePreview
-  };
-}
-
-// src/api/conversion/design-systems/brand.ts
-function designSystemBrandToDto(brand) {
-  return {
-    id: brand.id,
-    designSystemVersionId: brand.designSystemVersionId,
-    persistentId: brand.persistentId,
-    meta: {
-      name: brand.name,
-      description: brand.description
-    }
-  };
-}
-
-// src/api/conversion/design-systems/view.ts
-function elementViewToDto(elementView, columns) {
-  columns.sort((lhs, rhs) => lhs.sortPosition - rhs.sortPosition);
-  return {
-    id: elementView.id,
-    persistentId: elementView.persistentId,
-    targetElementType: elementView.targetElementType,
-    isDefault: elementView.isDefault,
-    meta: {
-      name: elementView.name,
-      description: elementView.description
-    },
-    columns
-  };
-}
-
 // ../model/dist/index.mjs
 import { z } from "zod";
 import { z as z2 } from "zod";
@@ -893,6 +804,7 @@ var PageBlockShortcut = z34.object({
   description: nullishToOptional(z34.string()),
   asset: nullishToOptional(PageBlockAsset),
   documentationItemId: nullishToOptional(z34.string()),
+  pageHeadingId: nullishToOptional(z34.string()),
   url: nullishToOptional(z34.string()),
   openInNewTab: nullishToOptional(z34.boolean()),
   urlPreview: nullishToOptional(PageBlockUrlPreview),
@@ -1287,8 +1199,8 @@ var defaultDocumentationItemHeaderV2 = {
 };
 var DocumentationItemConfigurationV2 = z41.object({
   showSidebar: z41.boolean(),
-  isPrivate: z41.boolean(),
-  isHidden: z41.boolean(),
+  isPrivate: z41.boolean().optional(),
+  isHidden: z41.boolean().optional(),
   header: DocumentationItemHeaderV2
 });
 var DocumentationPageDataV2 = z42.object({
@@ -2978,13 +2890,13 @@ var ExternalOAuthRequest = z137.object({
   state: z137.string(),
   createdAt: z137.coerce.date()
 });
-var IntegrationCredentialsType = z138.enum(["OAuth2", "PAT"]);
+var IntegrationCredentialsType = z138.enum(["OAuth2", "PAT", "GithubApp"]);
 var IntegrationCredentialsProfile = z138.object({
   id: z138.string(),
   username: z138.string().optional(),
   avatarUrl: z138.string().optional()
 });
-var IntegrationCredentialsSchema = z138.object({
+var IntegrationCredentials = z138.object({
   id: z138.string(),
   type: IntegrationCredentialsType,
   integrationId: z138.string(),
@@ -2992,7 +2904,8 @@ var IntegrationCredentialsSchema = z138.object({
   userId: z138.string(),
   createdAt: z138.coerce.date(),
   refreshToken: z138.string().optional(),
-  profile: IntegrationCredentialsProfile.optional()
+  profile: IntegrationCredentialsProfile.optional(),
+  customUrl: z138.string().optional()
 });
 var IntegrationType = z138.enum(["Figma", "Github", "Gitlab", "Bitbucket", "Azure"]);
 var Integration = z138.object({
@@ -3000,7 +2913,29 @@ var Integration = z138.object({
   workspaceId: z138.string(),
   type: IntegrationType,
   createdAt: z138.coerce.date(),
-  integrationCredentials: z138.array(IntegrationCredentialsSchema).optional()
+  integrationCredentials: z138.array(IntegrationCredentials).optional()
+});
+var forbiddenCustomUrldomainList = ["github.com", "gitlab.com", "bitbucket.org", "figma.com", "dev.azure.com"];
+var IntegrationTokenResponse = z138.object({
+  access_token: z138.string(),
+  refresh_token: z138.string().optional(),
+  expires_in: z138.number().optional(),
+  token_type: z138.string().optional(),
+  custom_url: z138.string().optional().refine((value) => {
+    if (!value)
+      return true;
+    if (forbiddenCustomUrldomainList.some((domain) => value.includes(domain)))
+      return false;
+    return true;
+  }, "Custom URL validation failed")
+}).transform((data) => {
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in,
+    tokenType: data.token_type,
+    customUrl: data.custom_url
+  };
 });
 var IntegrationTokenSchema = z139.object({
   id: z139.string(),
@@ -3788,7 +3723,7 @@ var RESERVED_SLUGS = [
 var RESERVED_SLUGS_SET = new Set(RESERVED_SLUGS);
 
 // src/api/conversion/documentation/documentation-item-configuration-v2-to-dto.ts
-var dtoDefaultItemConfigurationV2 = {
+var getDtoDefaultItemConfigurationV2 = () => ({
   showSidebar: true,
   isHidden: false,
   isPrivate: false,
@@ -3799,18 +3734,97 @@ var dtoDefaultItemConfigurationV2 = {
     showBackgroundOverlay: false,
     showCoverText: true
   }
-};
+});
 function documentationItemConfigurationToDTOV2(config) {
+  const dtoDefaultItemConfigurationV2 = getDtoDefaultItemConfigurationV2();
   if (!config)
     return dtoDefaultItemConfigurationV2;
   return {
     header: config.header,
-    isHidden: config.isHidden ?? dtoDefaultItemConfigurationV2.isPrivate,
+    isHidden: config.isHidden ?? dtoDefaultItemConfigurationV2.isHidden,
     isPrivate: config.isPrivate ?? dtoDefaultItemConfigurationV2.isPrivate,
     showSidebar: config.showSidebar
   };
 }
 
+// src/api/conversion/documentation/documentation-page-to-dto-utils.ts
+function buildDocPagePublishPaths(groups, pages, routingVersion) {
+  const groupPersistentIdToGroupMap = mapByUnique(groups, (group) => group.persistentId);
+  const result = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const parentChain = calculateElementParentChain(page.parentPersistentId, groupPersistentIdToGroupMap);
+    let pathV1 = `${page.userSlug || page.slug}.html`;
+    let pathV2 = `${slugify(page.meta.name)}-${page.shortPersistentId}`;
+    for (const parent of parentChain) {
+      if (!parent.parentPersistentId)
+        continue;
+      pathV1 = `${parent.userSlug || parent.slug}/${pathV1}`;
+      pathV2 = `${slugify(parent.meta.name)}/${pathV2}`;
+    }
+    pathV1 = `/${pathV1}`;
+    pathV2 = `/${pathV2}`;
+    if (routingVersion === "2") {
+      result.set(page.persistentId, pathV2);
+    } else {
+      result.set(page.persistentId, pathV1);
+    }
+  }
+  return result;
+}
+function calculateElementParentChain(elementParentPersistentId, groupPersistentIdToGroupMap) {
+  const result = [];
+  let parentId = elementParentPersistentId;
+  while (parentId) {
+    const parent = groupPersistentIdToGroupMap.get(parentId);
+    if (parent)
+      result.push(parent);
+    parentId = parent?.parentPersistentId;
+  }
+  return result;
+}
+function applyPrivacyConfigurationToNestedItems(pages, groups, getDefaultItemConfiguration) {
+  const fixedGroups = groups.map((group) => ({
+    ...group,
+    data: {
+      ...group.data,
+      configuration: group.data?.configuration ?? getDefaultItemConfiguration()
+    }
+  }));
+  const groupPersistentIdToGroupMap = mapByUnique(fixedGroups, (group) => group.persistentId);
+  for (const groupToFix of fixedGroups) {
+    let isHidden = groupToFix.data.configuration.isHidden;
+    let isPrivate = groupToFix.data.configuration.isPrivate;
+    let nextParentId = groupToFix.parentPersistentId;
+    while ((!isHidden || !isPrivate) && nextParentId) {
+      const parent = groupPersistentIdToGroupMap.get(nextParentId);
+      if (!parent)
+        break;
+      isHidden = isHidden || parent.data?.configuration?.isHidden || false;
+      isPrivate = isPrivate || parent.data?.configuration?.isPrivate || false;
+      nextParentId = parent.parentPersistentId;
+    }
+    groupToFix.data.configuration.isHidden = isHidden;
+    groupToFix.data.configuration.isPrivate = isPrivate;
+  }
+  const fixedPages = [];
+  for (const page of pages) {
+    const configuration = page.data?.configuration ?? getDefaultItemConfiguration();
+    const parent = groupPersistentIdToGroupMap.get(page.parentPersistentId);
+    fixedPages.push({
+      ...page,
+      data: {
+        ...page.data,
+        configuration: {
+          ...configuration,
+          isHidden: configuration.isHidden || parent?.data?.configuration?.isHidden || false,
+          isPrivate: configuration.isPrivate || parent?.data?.configuration?.isPrivate || false
+        }
+      }
+    });
+  }
+  return { pages: fixedPages, groups: fixedGroups };
+}
+
 // src/api/conversion/documentation/documentation-group-v2-to-dto.ts
 function elementGroupsToDocumentationGroupStructureDTOV2(groups, pages) {
   const childrenIdsMap = calculateChildrenIdsMapV2(pages, groups);
@@ -3818,12 +3832,12 @@ function elementGroupsToDocumentationGroupStructureDTOV2(groups, pages) {
 }
 function elementGroupsToDocumentationGroupDTOV2(groups, pages) {
   const childrenIdsMap = calculateChildrenIdsMapV2(pages, groups);
-  return groups.map((group) => {
-    return {
-      ...elementGroupToDocumentationGroupStructureDTOV2(group, childrenIdsMap),
-      configuration: documentationItemConfigurationToDTOV2(group.data?.configuration)
-    };
-  });
+  return groups.map((group) => elementGroupToDocumentationGroupStructureDTOV2(group, childrenIdsMap));
+}
+function elementGroupsToDocumentationGroupFixedConfigurationDTOV2(groups, pages) {
+  const childrenIdsMap = calculateChildrenIdsMapV2(pages, groups);
+  const { groups: fixedGroups } = applyPrivacyConfigurationToNestedItems(pages, groups, getDtoDefaultItemConfigurationV2);
+  return fixedGroups.map((group) => elementGroupToDocumentationGroupStructureDTOV2(group, childrenIdsMap));
 }
 function elementGroupToDocumentationGroupStructureDTOV2(group, childrenIdsMap) {
   const childrenIds = childrenIdsMap.get(group.persistentId) ?? [];
@@ -3862,42 +3876,6 @@ function calculateChildrenIdsMapV2(elements, groups) {
   return childrenIdsMap;
 }
 
-// src/api/conversion/documentation/documentation-page-to-dto-utils.ts
-function buildDocPagePublishPaths(groups, pages, routingVersion) {
-  const groupPersistentIdToGroupMap = mapByUnique(groups, (group) => group.persistentId);
-  const result = /* @__PURE__ */ new Map();
-  for (const page of pages) {
-    const parentChain = calculateElementParentChain(page.parentPersistentId, groupPersistentIdToGroupMap);
-    let pathV1 = `${page.userSlug || page.slug}.html`;
-    let pathV2 = `${slugify(page.meta.name)}-${page.shortPersistentId}`;
-    for (const parent of parentChain) {
-      if (!parent.parentPersistentId)
-        continue;
-      pathV1 = `${parent.userSlug || parent.slug}/${pathV1}`;
-      pathV2 = `${slugify(parent.meta.name)}/${pathV2}`;
-    }
-    pathV1 = `/${pathV1}`;
-    pathV2 = `/${pathV2}`;
-    if (routingVersion === "2") {
-      result.set(page.persistentId, pathV2);
-    } else {
-      result.set(page.persistentId, pathV1);
-    }
-  }
-  return result;
-}
-function calculateElementParentChain(elementParentPersistentId, groupPersistentIdToGroupMap) {
-  const result = [];
-  let parentId = elementParentPersistentId;
-  while (parentId) {
-    const parent = groupPersistentIdToGroupMap.get(parentId);
-    if (parent)
-      result.push(parent);
-    parentId = parent?.parentPersistentId;
-  }
-  return result;
-}
-
 // src/api/conversion/documentation/documentation-page-v2-to-dto.ts
 function documentationPagesToStructureDTOV2(pages, groups, routingVersion) {
   const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
@@ -3905,12 +3883,12 @@ function documentationPagesToStructureDTOV2(pages, groups, routingVersion) {
 }
 function documentationPagesToDTOV2(pages, groups, routingVersion) {
   const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
-  return pages.map((page) => {
-    return {
-      ...documentationPageToStructureDTOV2(page, pathsMap),
-      configuration: documentationItemConfigurationToDTOV2(page.data.configuration)
-    };
-  });
+  return pages.map((page) => documentationPageToStructureDTOV2(page, pathsMap));
+}
+function documentationPagesFixedConfigurationToDTOV2(pages, groups, routingVersion) {
+  const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
+  const { pages: fixedPages } = applyPrivacyConfigurationToNestedItems(pages, groups, getDtoDefaultItemConfigurationV2);
+  return fixedPages.map((page) => documentationPageToStructureDTOV2(page, pathsMap));
 }
 function documentationPageToStructureDTOV2(page, pagePathMap) {
   let path = pagePathMap.get(page.persistentId);
@@ -3943,7 +3921,7 @@ function documentationElementsToHierarchyDto(docPages, docGroups, routingVersion
 }
 
 // src/api/conversion/documentation/documentation-item-configuration-v1-to-dto.ts
-var dtoDefaultItemConfigurationV1 = {
+var getDtoDefaultItemConfigurationV1 = () => ({
   showSidebar: true,
   isHidden: false,
   isPrivate: false,
@@ -3954,12 +3932,14 @@ var dtoDefaultItemConfigurationV1 = {
     showBackgroundOverlay: false,
     showCoverText: true
   }
-};
+});
 function documentationItemConfigurationToDTOV1(config) {
-  const { header, showSidebar } = config;
-  const { backgroundColor, foregroundColor, ...headerRest } = header;
+  const dtoDefaultItemConfigurationV1 = getDtoDefaultItemConfigurationV1();
+  if (!config)
+    return dtoDefaultItemConfigurationV1;
+  const { backgroundColor, foregroundColor, ...headerRest } = config.header;
   return {
-    showSidebar,
+    showSidebar: config.showSidebar,
     isHidden: config.isHidden ?? dtoDefaultItemConfigurationV1.isHidden,
     isPrivate: config.isPrivate ?? dtoDefaultItemConfigurationV1.isPrivate,
     header: {
@@ -3993,7 +3973,17 @@ function elementGroupsToDocumentationGroupDTOV1(groups, pages) {
   return groups.map((group) => {
     return {
       ...elementGroupToDocumentationGroupStructureDTOV1(group, childrenIdsMap),
-      configuration: group.data?.configuration ? documentationItemConfigurationToDTOV1(group.data.configuration) : dtoDefaultItemConfigurationV1
+      configuration: documentationItemConfigurationToDTOV1(group.data?.configuration)
+    };
+  });
+}
+function elementGroupsToDocumentationGroupFixedConfigurationDTOV1(groups, pages) {
+  const childrenIdsMap = calculateChildrenIdsMapV1(pages, groups);
+  const { groups: fixedGroups } = applyPrivacyConfigurationToNestedItems(pages, groups, getDtoDefaultItemConfigurationV1);
+  return fixedGroups.map((group) => {
+    return {
+      ...elementGroupToDocumentationGroupStructureDTOV1(group, childrenIdsMap),
+      configuration: documentationItemConfigurationToDTOV1(group.data?.configuration)
     };
   });
 }
@@ -4036,27 +4026,33 @@ function calculateChildrenIdsMapV1(elements, groups) {
 // src/api/conversion/documentation/documentation-page-v1-to-dto.ts
 function documentationPagesToDTOV1(pages, groups, routingVersion) {
   const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
-  return pages.map((page) => {
-    let path = pathsMap.get(page.persistentId);
-    if (!path)
-      throw SupernovaException.conflict(`Path for page ${page.id} was not calculated`);
-    if (path.startsWith("/"))
-      path = path.substring(1);
-    return {
-      id: page.id,
-      designSystemVersionId: page.designSystemVersionId,
-      persistentId: page.persistentId,
-      shortPersistentId: page.shortPersistentId,
-      title: page.meta.name,
-      blocks: page.data.blocks,
-      slug: page.slug,
-      userSlug: page.userSlug,
-      configuration: page.data.configuration ? documentationItemConfigurationToDTOV1(page.data.configuration) : dtoDefaultItemConfigurationV1,
-      createdAt: page.createdAt,
-      updatedAt: page.updatedAt,
-      path
-    };
-  });
+  return pages.map((page) => documentationPageToDTOV1(page, pathsMap));
+}
+function documentationPagesFixedConfigurationToDTOV1(pages, groups, routingVersion) {
+  const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
+  const { pages: fixedPages } = applyPrivacyConfigurationToNestedItems(pages, groups, getDtoDefaultItemConfigurationV1);
+  return fixedPages.map((page) => documentationPageToDTOV1(page, pathsMap));
+}
+function documentationPageToDTOV1(page, pagePathMap) {
+  let path = pagePathMap.get(page.persistentId);
+  if (!path)
+    throw SupernovaException.conflict(`Path for page ${page.id} was not calculated`);
+  if (path.startsWith("/"))
+    path = path.substring(1);
+  return {
+    id: page.id,
+    designSystemVersionId: page.designSystemVersionId,
+    persistentId: page.persistentId,
+    shortPersistentId: page.shortPersistentId,
+    title: page.meta.name,
+    blocks: page.data.blocks,
+    slug: page.slug,
+    userSlug: page.userSlug,
+    configuration: documentationItemConfigurationToDTOV1(page.data.configuration),
+    createdAt: page.createdAt,
+    updatedAt: page.updatedAt,
+    path
+  };
 }
 
 // src/api/conversion/integrations/integration.ts
@@ -4101,89 +4097,198 @@ var DTOExporterProperty = z147.any({});
 var DTOExporterPropertyListResponse = z147.object({ items: z147.array(DTOExporterProperty) });
 
 // src/api/dto/design-systems/version.ts
+import { z as z154 } from "zod";
+
+// src/api/payloads/design-systems/brand.ts
 import { z as z148 } from "zod";
-var DTODesignSystemVersion = z148.object({
-  id: z148.string(),
-  createdAt: z148.date(),
+var DTOCreateBrandInput = z148.object({
+  persistentId: z148.string().uuid(),
+  meta: z148.object({
+    name: z148.string(),
+    description: z148.string()
+  })
+});
+
+// src/api/payloads/design-systems/version.ts
+import { z as z149 } from "zod";
+var ObjectMeta2 = z149.object({
+  name: z149.string().max(150).optional(),
+  description: z149.string().max(2e3).optional()
+});
+function validateSemver(version) {
+  const semverRegex = /^(\d+)(\.\d+)?(\.\d+)?$/;
+  return semverRegex.test(version);
+}
+var DTOCreateVersionInput = z149.object({
+  meta: ObjectMeta2,
+  version: z149.string().refine(validateSemver, {
+    message: "Invalid semantic versioning format"
+  }),
+  changeLog: z149.string().max(2e3).optional()
+});
+
+// src/api/payloads/documentation/block-definitions.ts
+import { z as z150 } from "zod";
+var DTOGetBlockDefinitionsOutput = z150.object({
+  definitions: z150.array(PageBlockDefinition)
+});
+
+// src/api/payloads/liveblocks/auth.ts
+import { z as z151 } from "zod";
+var DTOLiveblocksAuthRequest = z151.object({
+  room: z151.string().optional()
+});
+
+// src/api/payloads/workspaces/workspace-configuration.ts
+import { z as z152 } from "zod";
+var prohibitedSsoKeys = ["providerId", "metadataXml", "emailDomains"];
+function validateSsoPayload(ssoPayload) {
+  const keys = [];
+  let valid = true;
+  if (!ssoPayload) {
+    valid = true;
+    return {
+      valid,
+      keys: []
+    };
+  }
+  for (const key of Object.keys(ssoPayload)) {
+    if (prohibitedSsoKeys.includes(key)) {
+      keys.push(key);
+      valid = false;
+    }
+  }
+  return {
+    valid,
+    keys
+  };
+}
+var NpmRegistryInput = z152.object({
+  enabledScopes: z152.array(z152.string()),
+  customRegistryUrl: z152.string().optional(),
+  bypassProxy: z152.boolean().optional(),
+  npmProxyRegistryConfigId: z152.string().optional(),
+  npmProxyVersion: z152.number().optional(),
+  registryType: z152.string(),
+  authType: z152.string(),
+  authHeaderName: z152.string(),
+  authHeaderValue: z152.string(),
+  accessToken: z152.string(),
+  username: z152.string(),
+  password: z152.string()
+});
+var WorkspaceConfigurationPayload = z152.object({
+  ipWhitelist: WorkspaceIpSettings.partial().optional(),
+  sso: SsoProvider.partial().optional(),
+  npmRegistrySettings: NpmRegistryInput.partial().optional(),
+  profile: WorkspaceProfile.partial().optional()
+});
+
+// src/api/payloads/workspaces/workspace-integrations.ts
+import { z as z153 } from "zod";
+var DTOWorkspaceIntegrationOauthInput = z153.object({
+  type: IntegrationType
+});
+var DTOWorkspaceIntegrationPATInput = z153.object({
+  userId: z153.string(),
+  type: IntegrationType,
+  token: IntegrationTokenResponse
+});
+
+// src/api/dto/design-systems/version.ts
+var DTODesignSystemVersion = z154.object({
+  id: z154.string(),
+  createdAt: z154.date(),
   meta: ObjectMeta,
-  version: z148.string(),
-  isReadonly: z148.boolean(),
-  changeLog: z148.string(),
-  designSystemId: z148.string()
+  version: z154.string(),
+  isReadonly: z154.boolean(),
+  changeLog: z154.string(),
+  designSystemId: z154.string()
 });
-var DTODesignSystemVersionsListResponse = z148.object({
-  designSystemVersions: z148.array(DTODesignSystemVersion)
+var DTODesignSystemVersionsListResponse = z154.object({
+  designSystemVersions: z154.array(DTODesignSystemVersion)
 });
-var DTODesignSystemVersionGetResponse = z148.object({
+var DTODesignSystemVersionGetResponse = z154.object({
   designSystemVersion: DTODesignSystemVersion
 });
+var DTODesignSystemVersionCreationResponse = z154.object({
+  meta: ObjectMeta,
+  version: z154.string(),
+  changeLog: z154.string(),
+  isReadOnly: z154.boolean(),
+  designSystemId: z154.string()
+});
+var VersionSQSPayload = z154.object({
+  designSystemId: z154.string(),
+  input: DTOCreateVersionInput
+});
 
 // src/api/dto/design-systems/view.ts
-import { z as z149 } from "zod";
-var DTOElementViewColumnSharedAttributes = z149.object({
-  id: z149.string(),
-  persistentId: z149.string(),
-  width: z149.number()
+import { z as z155 } from "zod";
+var DTOElementViewColumnSharedAttributes = z155.object({
+  id: z155.string(),
+  persistentId: z155.string(),
+  width: z155.number()
 });
 var DTOElementViewBasePropertyColumn = DTOElementViewColumnSharedAttributes.extend({
-  type: z149.literal("BaseProperty"),
+  type: z155.literal("BaseProperty"),
   basePropertyType: ElementViewBaseColumnType
 });
 var DTOElementViewPropertyDefinitionColumn = DTOElementViewColumnSharedAttributes.extend({
-  type: z149.literal("PropertyDefinition"),
-  propertyDefinitionId: z149.string()
+  type: z155.literal("PropertyDefinition"),
+  propertyDefinitionId: z155.string()
 });
 var DTOElementViewThemeColumn = DTOElementViewColumnSharedAttributes.extend({
-  type: z149.literal("Theme"),
-  themeId: z149.string()
+  type: z155.literal("Theme"),
+  themeId: z155.string()
 });
-var DTOElementViewColumn = z149.discriminatedUnion("type", [
+var DTOElementViewColumn = z155.discriminatedUnion("type", [
   DTOElementViewBasePropertyColumn,
   DTOElementViewPropertyDefinitionColumn,
   DTOElementViewThemeColumn
 ]);
-var DTOElementView = z149.object({
+var DTOElementView = z155.object({
   meta: ObjectMeta,
-  persistentId: z149.string(),
+  persistentId: z155.string(),
   targetElementType: ElementPropertyTargetType,
-  id: z149.string(),
-  isDefault: z149.boolean(),
-  columns: z149.array(DTOElementViewColumn)
+  id: z155.string(),
+  isDefault: z155.boolean(),
+  columns: z155.array(DTOElementViewColumn)
 });
-var DTOElementViewsListResponse = z149.object({
-  elementDataViews: z149.array(DTOElementView)
+var DTOElementViewsListResponse = z155.object({
+  elementDataViews: z155.array(DTOElementView)
 });
 
 // src/api/dto/documentation/anchor.ts
-import { z as z150 } from "zod";
+import { z as z156 } from "zod";
 var DTODocumentationPageAnchor = DocumentationPageAnchor;
-var DTOGetDocumentationPageAnchorsResponse = z150.object({
-  anchors: z150.array(DTODocumentationPageAnchor)
+var DTOGetDocumentationPageAnchorsResponse = z156.object({
+  anchors: z156.array(DTODocumentationPageAnchor)
 });
 
 // src/api/dto/documentation/link-preview.ts
-import { z as z151 } from "zod";
-var DTODocumentationLinkPreviewResponse = z151.object({
+import { z as z157 } from "zod";
+var DTODocumentationLinkPreviewResponse = z157.object({
   linkPreview: DocumentationLinkPreview
 });
-var DTODocumentationLinkPreviewRequest = z151.object({
-  url: z151.string().optional(),
-  documentationItemPersistentId: z151.string().optional()
+var DTODocumentationLinkPreviewRequest = z157.object({
+  url: z157.string().optional(),
+  documentationItemPersistentId: z157.string().optional()
 });
 
 // src/api/dto/elements/documentation/group-action.ts
-import { z as z154 } from "zod";
+import { z as z160 } from "zod";
 
 // src/api/dto/elements/documentation/group-v2.ts
-import { z as z153 } from "zod";
+import { z as z159 } from "zod";
 
 // src/api/dto/elements/documentation/item-configuration-v2.ts
-import { z as z152 } from "zod";
+import { z as z158 } from "zod";
 var DTODocumentationItemHeaderV2 = DocumentationItemHeaderV2;
-var DTODocumentationItemConfigurationV2 = z152.object({
-  showSidebar: z152.boolean(),
-  isPrivate: z152.boolean(),
-  isHidden: z152.boolean(),
+var DTODocumentationItemConfigurationV2 = z158.object({
+  showSidebar: z158.boolean(),
+  isPrivate: z158.boolean(),
+  isHidden: z158.boolean(),
   header: DTODocumentationItemHeaderV2
 });
 
@@ -4197,136 +4302,136 @@ var DTODocumentationGroupV2 = ElementGroup.omit({
   data: true,
   shortPersistentId: true
 }).extend({
-  title: z153.string(),
-  isRoot: z153.boolean(),
-  childrenIds: z153.array(z153.string()),
+  title: z159.string(),
+  isRoot: z159.boolean(),
+  childrenIds: z159.array(z159.string()),
   groupBehavior: DocumentationGroupBehavior,
-  shortPersistentId: z153.string(),
+  shortPersistentId: z159.string(),
   configuration: DTODocumentationItemConfigurationV2,
-  type: z153.literal("Group")
+  type: z159.literal("Group")
 });
 var DTODocumentationGroupStructureV2 = DTODocumentationGroupV2;
-var DTOCreateDocumentationGroupInput = z153.object({
+var DTOCreateDocumentationGroupInput = z159.object({
   // Identifier
-  persistentId: z153.string().uuid(),
+  persistentId: z159.string().uuid(),
   // Group properties
-  title: z153.string(),
+  title: z159.string(),
   configuration: DTODocumentationItemConfigurationV2.optional(),
   // Group placement properties
-  afterPersistentId: z153.string().uuid().nullish(),
-  parentPersistentId: z153.string().uuid()
+  afterPersistentId: z159.string().uuid().nullish(),
+  parentPersistentId: z159.string().uuid()
 });
-var DTOUpdateDocumentationGroupInput = z153.object({
+var DTOUpdateDocumentationGroupInput = z159.object({
   // Identifier of the group to update
-  id: z153.string(),
+  id: z159.string(),
   // Group properties
-  title: z153.string().optional(),
+  title: z159.string().optional(),
   configuration: DTODocumentationItemConfigurationV2.partial().optional()
 });
-var DTOMoveDocumentationGroupInput = z153.object({
+var DTOMoveDocumentationGroupInput = z159.object({
   // Identifier of the group to update
-  id: z153.string(),
+  id: z159.string(),
   // Group placement properties
-  parentPersistentId: z153.string().uuid(),
-  afterPersistentId: z153.string().uuid().nullish()
+  parentPersistentId: z159.string().uuid(),
+  afterPersistentId: z159.string().uuid().nullish()
 });
-var DTODuplicateDocumentationGroupInput = z153.object({
+var DTODuplicateDocumentationGroupInput = z159.object({
   // Identifier of the group to duplicate from
-  id: z153.string(),
+  id: z159.string(),
   // New group persistent id
-  persistentId: z153.string().uuid(),
+  persistentId: z159.string().uuid(),
   // Group placement properties
-  afterPersistentId: z153.string().uuid().nullish(),
-  parentPersistentId: z153.string().uuid()
+  afterPersistentId: z159.string().uuid().nullish(),
+  parentPersistentId: z159.string().uuid()
 });
-var DTOCreateDocumentationTabInput = z153.object({
+var DTOCreateDocumentationTabInput = z159.object({
   // New group persistent id
-  persistentId: z153.string().uuid(),
+  persistentId: z159.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: z153.string(),
-  tabName: z153.string()
+  fromItemPersistentId: z159.string(),
+  tabName: z159.string()
 });
-var DTODeleteDocumentationTabGroupInput = z153.object({
+var DTODeleteDocumentationTabGroupInput = z159.object({
   // Deleted group id
-  id: z153.string()
+  id: z159.string()
 });
-var DTODeleteDocumentationGroupInput = z153.object({
+var DTODeleteDocumentationGroupInput = z159.object({
   // Identifier
-  id: z153.string(),
+  id: z159.string(),
   // Deletion options
-  deleteSubtree: z153.boolean().default(false)
+  deleteSubtree: z159.boolean().default(false)
 });
 
 // src/api/dto/elements/documentation/group-action.ts
-var SuccessPayload = z154.object({
-  success: z154.literal(true)
+var SuccessPayload = z160.object({
+  success: z160.literal(true)
 });
-var DTODocumentationGroupCreateActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationGroupCreate"),
+var DTODocumentationGroupCreateActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationGroupCreate"),
   output: SuccessPayload
 });
-var DTODocumentationTabCreateActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationTabCreate"),
+var DTODocumentationTabCreateActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationTabCreate"),
   output: SuccessPayload
 });
-var DTODocumentationGroupUpdateActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationGroupUpdate"),
+var DTODocumentationGroupUpdateActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationGroupUpdate"),
   output: SuccessPayload
 });
-var DTODocumentationGroupMoveActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationGroupMove"),
+var DTODocumentationGroupMoveActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationGroupMove"),
   output: SuccessPayload
 });
-var DTODocumentationGroupDuplicateActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationGroupDuplicate"),
+var DTODocumentationGroupDuplicateActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationGroupDuplicate"),
   output: SuccessPayload
 });
-var DTODocumentationGroupDeleteActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationGroupDelete"),
+var DTODocumentationGroupDeleteActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationGroupDelete"),
   output: SuccessPayload
 });
-var DTODocumentationTabGroupDeleteActionOutputV2 = z154.object({
-  type: z154.literal("DocumentationTabGroupDelete"),
+var DTODocumentationTabGroupDeleteActionOutputV2 = z160.object({
+  type: z160.literal("DocumentationTabGroupDelete"),
   output: SuccessPayload
 });
-var DTODocumentationGroupCreateActionInputV2 = z154.object({
-  type: z154.literal("DocumentationGroupCreate"),
+var DTODocumentationGroupCreateActionInputV2 = z160.object({
+  type: z160.literal("DocumentationGroupCreate"),
   input: DTOCreateDocumentationGroupInput
 });
-var DTODocumentationTabCreateActionInputV2 = z154.object({
-  type: z154.literal("DocumentationTabCreate"),
+var DTODocumentationTabCreateActionInputV2 = z160.object({
+  type: z160.literal("DocumentationTabCreate"),
   input: DTOCreateDocumentationTabInput
 });
-var DTODocumentationGroupUpdateActionInputV2 = z154.object({
-  type: z154.literal("DocumentationGroupUpdate"),
+var DTODocumentationGroupUpdateActionInputV2 = z160.object({
+  type: z160.literal("DocumentationGroupUpdate"),
   input: DTOUpdateDocumentationGroupInput
 });
-var DTODocumentationGroupMoveActionInputV2 = z154.object({
-  type: z154.literal("DocumentationGroupMove"),
+var DTODocumentationGroupMoveActionInputV2 = z160.object({
+  type: z160.literal("DocumentationGroupMove"),
   input: DTOMoveDocumentationGroupInput
 });
-var DTODocumentationGroupDuplicateActionInputV2 = z154.object({
-  type: z154.literal("DocumentationGroupDuplicate"),
+var DTODocumentationGroupDuplicateActionInputV2 = z160.object({
+  type: z160.literal("DocumentationGroupDuplicate"),
   input: DTODuplicateDocumentationGroupInput
 });
-var DTODocumentationGroupDeleteActionInputV2 = z154.object({
-  type: z154.literal("DocumentationGroupDelete"),
+var DTODocumentationGroupDeleteActionInputV2 = z160.object({
+  type: z160.literal("DocumentationGroupDelete"),
   input: DTODeleteDocumentationGroupInput
 });
-var DTODocumentationTabGroupDeleteActionInputV2 = z154.object({
-  type: z154.literal("DocumentationTabGroupDelete"),
+var DTODocumentationTabGroupDeleteActionInputV2 = z160.object({
+  type: z160.literal("DocumentationTabGroupDelete"),
   input: DTODeleteDocumentationTabGroupInput
 });
 
 // src/api/dto/elements/documentation/group-v1.ts
-import { z as z156 } from "zod";
+import { z as z162 } from "zod";
 
 // src/api/dto/elements/documentation/item-configuration-v1.ts
-import { z as z155 } from "zod";
-var DocumentationColorV1 = z155.object({
-  aliasTo: z155.string().optional(),
-  value: z155.string().optional()
+import { z as z161 } from "zod";
+var DocumentationColorV1 = z161.object({
+  aliasTo: z161.string().optional(),
+  value: z161.string().optional()
 });
 var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
   foregroundColor: true,
@@ -4335,10 +4440,10 @@ var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
   foregroundColor: DocumentationColorV1.optional(),
   backgroundColor: DocumentationColorV1.optional()
 });
-var DTODocumentationItemConfigurationV1 = z155.object({
-  showSidebar: z155.boolean(),
-  isPrivate: z155.boolean(),
-  isHidden: z155.boolean(),
+var DTODocumentationItemConfigurationV1 = z161.object({
+  showSidebar: z161.boolean(),
+  isPrivate: z161.boolean(),
+  isHidden: z161.boolean(),
   header: DTODocumentationItemHeaderV1
 });
 
@@ -4352,130 +4457,130 @@ var DTODocumentationGroupStructureV1 = ElementGroup.omit({
   data: true,
   shortPersistentId: true
 }).extend({
-  title: z156.string(),
-  isRoot: z156.boolean(),
-  childrenIds: z156.array(z156.string()),
+  title: z162.string(),
+  isRoot: z162.boolean(),
+  childrenIds: z162.array(z162.string()),
   groupBehavior: DocumentationGroupBehavior,
-  shortPersistentId: z156.string(),
-  type: z156.literal("Group")
+  shortPersistentId: z162.string(),
+  type: z162.literal("Group")
 });
 var DTODocumentationGroupV1 = DTODocumentationGroupStructureV1.extend({
   configuration: DTODocumentationItemConfigurationV1
 });
 
 // src/api/dto/elements/documentation/page-actions-v2.ts
-import { z as z158 } from "zod";
+import { z as z164 } from "zod";
 
 // src/api/dto/elements/documentation/page-v2.ts
-import { z as z157 } from "zod";
+import { z as z163 } from "zod";
 var DTODocumentationPageV2 = DocumentationPageV2.omit({
   data: true,
   meta: true,
   parentPersistentId: true,
   sortOrder: true
 }).extend({
-  title: z157.string(),
-  path: z157.string(),
-  type: z157.literal("Page"),
+  title: z163.string(),
+  path: z163.string(),
+  type: z163.literal("Page"),
   configuration: DTODocumentationItemConfigurationV2
 });
 var DTODocumentationPageStructureV2 = DTODocumentationPageV2;
-var DTODocumentationHierarchyV2 = z157.object({
-  pages: z157.array(DTODocumentationPageStructureV2),
-  groups: z157.array(DTODocumentationGroupStructureV2)
+var DTODocumentationHierarchyV2 = z163.object({
+  pages: z163.array(DTODocumentationPageStructureV2),
+  groups: z163.array(DTODocumentationGroupStructureV2)
 });
-var DTOCreateDocumentationPageInputV2 = z157.object({
+var DTOCreateDocumentationPageInputV2 = z163.object({
   // Identifier
-  persistentId: z157.string().uuid(),
+  persistentId: z163.string().uuid(),
   // Page properties
-  title: z157.string(),
+  title: z163.string(),
   configuration: DTODocumentationItemConfigurationV2.optional(),
   // Page placement properties
-  parentPersistentId: z157.string().uuid(),
-  afterPersistentId: z157.string().uuid().nullish()
+  parentPersistentId: z163.string().uuid(),
+  afterPersistentId: z163.string().uuid().nullish()
 });
-var DTOUpdateDocumentationPageInputV2 = z157.object({
+var DTOUpdateDocumentationPageInputV2 = z163.object({
   // Identifier of the group to update
-  id: z157.string(),
+  id: z163.string(),
   // Page properties
-  title: z157.string().optional(),
+  title: z163.string().optional(),
   configuration: DTODocumentationItemConfigurationV2.partial().optional()
 });
-var DTOMoveDocumentationPageInputV2 = z157.object({
+var DTOMoveDocumentationPageInputV2 = z163.object({
   // Identifier of the group to update
-  id: z157.string(),
+  id: z163.string(),
   // Page placement properties
-  parentPersistentId: z157.string().uuid(),
-  afterPersistentId: z157.string().uuid().nullish()
+  parentPersistentId: z163.string().uuid(),
+  afterPersistentId: z163.string().uuid().nullish()
 });
-var DTODuplicateDocumentationPageInputV2 = z157.object({
+var DTODuplicateDocumentationPageInputV2 = z163.object({
   // Identifier of the page to duplicate from
-  id: z157.string(),
+  id: z163.string(),
   // New page persistent id
-  persistentId: z157.string().uuid(),
+  persistentId: z163.string().uuid(),
   // Page placement properties
-  parentPersistentId: z157.string().uuid(),
-  afterPersistentId: z157.string().uuid().nullish()
+  parentPersistentId: z163.string().uuid(),
+  afterPersistentId: z163.string().uuid().nullish()
 });
-var DTODeleteDocumentationPageInputV2 = z157.object({
+var DTODeleteDocumentationPageInputV2 = z163.object({
   // Identifier
-  id: z157.string()
+  id: z163.string()
 });
 
 // src/api/dto/elements/documentation/page-actions-v2.ts
-var SuccessPayload2 = z158.object({
-  success: z158.literal(true)
+var SuccessPayload2 = z164.object({
+  success: z164.literal(true)
 });
-var DTODocumentationPageCreateActionOutputV2 = z158.object({
-  type: z158.literal("DocumentationPageCreate"),
+var DTODocumentationPageCreateActionOutputV2 = z164.object({
+  type: z164.literal("DocumentationPageCreate"),
   output: SuccessPayload2
 });
-var DTODocumentationPageUpdateActionOutputV2 = z158.object({
-  type: z158.literal("DocumentationPageUpdate"),
+var DTODocumentationPageUpdateActionOutputV2 = z164.object({
+  type: z164.literal("DocumentationPageUpdate"),
   output: SuccessPayload2
 });
-var DTODocumentationPageMoveActionOutputV2 = z158.object({
-  type: z158.literal("DocumentationPageMove"),
+var DTODocumentationPageMoveActionOutputV2 = z164.object({
+  type: z164.literal("DocumentationPageMove"),
   output: SuccessPayload2
 });
-var DTODocumentationPageDuplicateActionOutputV2 = z158.object({
-  type: z158.literal("DocumentationPageDuplicate"),
+var DTODocumentationPageDuplicateActionOutputV2 = z164.object({
+  type: z164.literal("DocumentationPageDuplicate"),
   output: SuccessPayload2
 });
-var DTODocumentationPageDeleteActionOutputV2 = z158.object({
-  type: z158.literal("DocumentationPageDelete"),
+var DTODocumentationPageDeleteActionOutputV2 = z164.object({
+  type: z164.literal("DocumentationPageDelete"),
   output: SuccessPayload2
 });
-var DTODocumentationPageCreateActionInputV2 = z158.object({
-  type: z158.literal("DocumentationPageCreate"),
+var DTODocumentationPageCreateActionInputV2 = z164.object({
+  type: z164.literal("DocumentationPageCreate"),
   input: DTOCreateDocumentationPageInputV2
 });
-var DTODocumentationPageUpdateActionInputV2 = z158.object({
-  type: z158.literal("DocumentationPageUpdate"),
+var DTODocumentationPageUpdateActionInputV2 = z164.object({
+  type: z164.literal("DocumentationPageUpdate"),
   input: DTOUpdateDocumentationPageInputV2
 });
-var DTODocumentationPageMoveActionInputV2 = z158.object({
-  type: z158.literal("DocumentationPageMove"),
+var DTODocumentationPageMoveActionInputV2 = z164.object({
+  type: z164.literal("DocumentationPageMove"),
   input: DTOMoveDocumentationPageInputV2
 });
-var DTODocumentationPageDuplicateActionInputV2 = z158.object({
-  type: z158.literal("DocumentationPageDuplicate"),
+var DTODocumentationPageDuplicateActionInputV2 = z164.object({
+  type: z164.literal("DocumentationPageDuplicate"),
   input: DTODuplicateDocumentationPageInputV2
 });
-var DTODocumentationPageDeleteActionInputV2 = z158.object({
-  type: z158.literal("DocumentationPageDelete"),
+var DTODocumentationPageDeleteActionInputV2 = z164.object({
+  type: z164.literal("DocumentationPageDelete"),
   input: DTODeleteDocumentationPageInputV2
 });
 
 // src/api/dto/elements/documentation/page-content.ts
-import { z as z159 } from "zod";
+import { z as z165 } from "zod";
 var DTODocumentationPageContent = DocumentationPageContent;
-var DTODocumentationPageContentGetResponse = z159.object({
+var DTODocumentationPageContentGetResponse = z165.object({
   pageContent: DTODocumentationPageContent
 });
 
 // src/api/dto/elements/documentation/page-v1.ts
-import { z as z160 } from "zod";
+import { z as z166 } from "zod";
 var DocumentationPageV1DTO = DocumentationPageV1.omit({
   data: true,
   meta: true,
@@ -4483,130 +4588,130 @@ var DocumentationPageV1DTO = DocumentationPageV1.omit({
   sortOrder: true
 }).extend({
   configuration: DTODocumentationItemConfigurationV1,
-  blocks: z160.array(PageBlockV1),
-  title: z160.string(),
-  path: z160.string()
+  blocks: z166.array(PageBlockV1),
+  title: z166.string(),
+  path: z166.string()
 });
 
 // src/api/dto/elements/figma-nodes/figma-node.ts
-import { z as z161 } from "zod";
-var DTOFigmaNodeData = z161.object({
+import { z as z167 } from "zod";
+var DTOFigmaNodeData = z167.object({
   // Id of the node in the Figma file
-  figmaNodeId: z161.string(),
+  figmaNodeId: z167.string(),
   // Validity
-  isValid: z161.boolean(),
+  isValid: z167.boolean(),
   // Asset data
-  assetId: z161.string(),
-  assetUrl: z161.string(),
+  assetId: z167.string(),
+  assetUrl: z167.string(),
   // Asset metadata
-  assetScale: z161.number(),
-  assetWidth: z161.number().optional(),
-  assetHeight: z161.number().optional()
+  assetScale: z167.number(),
+  assetWidth: z167.number().optional(),
+  assetHeight: z167.number().optional()
 });
 var DTOFigmaNode = FigmaFileStructure.omit({
   data: true
 }).extend({
   data: DTOFigmaNodeData
 });
-var DTOFigmaNodeRenderInput = z161.object({
+var DTOFigmaNodeRenderInput = z167.object({
   // Id of a design system's data source representing a linked Figma file
-  sourceId: z161.string(),
+  sourceId: z167.string(),
   // Id of a node within the Figma file
-  figmaFileNodeId: z161.string()
+  figmaFileNodeId: z167.string()
 });
 
 // src/api/dto/elements/figma-nodes/node-actions-v2.ts
-import { z as z162 } from "zod";
-var DTOFigmaNodeRenderActionOutput = z162.object({
-  type: z162.literal("FigmaNodeRender"),
-  figmaNodes: z162.array(DTOFigmaNode)
+import { z as z168 } from "zod";
+var DTOFigmaNodeRenderActionOutput = z168.object({
+  type: z168.literal("FigmaNodeRender"),
+  figmaNodes: z168.array(DTOFigmaNode)
 });
-var DTOFigmaNodeRenderActionInput = z162.object({
-  type: z162.literal("FigmaNodeRender"),
+var DTOFigmaNodeRenderActionInput = z168.object({
+  type: z168.literal("FigmaNodeRender"),
   input: DTOFigmaNodeRenderInput.array()
 });
 
 // src/api/dto/elements/properties/property-definitions-actions-v2.ts
-import { z as z164 } from "zod";
+import { z as z170 } from "zod";
 
 // src/api/dto/elements/properties/property-definitions.ts
-import { z as z163 } from "zod";
+import { z as z169 } from "zod";
 var CODE_NAME_REGEX2 = /^[a-zA-Z_$][a-zA-Z_$0-9]{1,99}$/;
-var DTOElementPropertyDefinition = z163.object({
-  id: z163.string(),
-  designSystemVersionId: z163.string(),
+var DTOElementPropertyDefinition = z169.object({
+  id: z169.string(),
+  designSystemVersionId: z169.string(),
   meta: ObjectMeta,
-  persistentId: z163.string(),
+  persistentId: z169.string(),
   type: ElementPropertyTypeSchema,
   targetElementType: ElementPropertyTargetType,
-  codeName: z163.string().regex(CODE_NAME_REGEX2),
-  options: z163.array(ElementPropertyDefinitionOption).optional(),
+  codeName: z169.string().regex(CODE_NAME_REGEX2),
+  options: z169.array(ElementPropertyDefinitionOption).optional(),
   linkElementType: ElementPropertyLinkType.optional()
 });
-var DTOElementPropertyDefinitionsGetResponse = z163.object({
-  definitions: z163.array(DTOElementPropertyDefinition)
+var DTOElementPropertyDefinitionsGetResponse = z169.object({
+  definitions: z169.array(DTOElementPropertyDefinition)
 });
 var DTOCreateElementPropertyDefinitionInputV2 = DTOElementPropertyDefinition.omit({
   id: true,
   designSystemVersionId: true
 });
-var DTOUpdateElementPropertyDefinitionInputV2 = z163.object({
-  id: z163.string(),
-  name: z163.string().optional(),
-  description: z163.string().optional(),
-  codeName: z163.string().regex(CODE_NAME_REGEX2).optional(),
-  options: z163.array(ElementPropertyDefinitionOption).optional()
+var DTOUpdateElementPropertyDefinitionInputV2 = z169.object({
+  id: z169.string(),
+  name: z169.string().optional(),
+  description: z169.string().optional(),
+  codeName: z169.string().regex(CODE_NAME_REGEX2).optional(),
+  options: z169.array(ElementPropertyDefinitionOption).optional()
 });
-var DTODeleteElementPropertyDefinitionInputV2 = z163.object({
-  id: z163.string()
+var DTODeleteElementPropertyDefinitionInputV2 = z169.object({
+  id: z169.string()
 });
 
 // src/api/dto/elements/properties/property-definitions-actions-v2.ts
-var SuccessPayload3 = z164.object({
-  success: z164.literal(true)
+var SuccessPayload3 = z170.object({
+  success: z170.literal(true)
 });
-var DTOPropertyDefinitionCreateActionOutputV2 = z164.object({
-  type: z164.literal("PropertyDefinitionCreate"),
+var DTOPropertyDefinitionCreateActionOutputV2 = z170.object({
+  type: z170.literal("PropertyDefinitionCreate"),
   definition: DTOElementPropertyDefinition
 });
-var DTOPropertyDefinitionUpdateActionOutputV2 = z164.object({
-  type: z164.literal("PropertyDefinitionUpdate"),
+var DTOPropertyDefinitionUpdateActionOutputV2 = z170.object({
+  type: z170.literal("PropertyDefinitionUpdate"),
   definition: DTOElementPropertyDefinition
 });
-var DTOPropertyDefinitionDeleteActionOutputV2 = z164.object({
-  type: z164.literal("PropertyDefinitionDelete"),
+var DTOPropertyDefinitionDeleteActionOutputV2 = z170.object({
+  type: z170.literal("PropertyDefinitionDelete"),
   output: SuccessPayload3
 });
-var DTOPropertyDefinitionCreateActionInputV2 = z164.object({
-  type: z164.literal("PropertyDefinitionCreate"),
+var DTOPropertyDefinitionCreateActionInputV2 = z170.object({
+  type: z170.literal("PropertyDefinitionCreate"),
   input: DTOCreateElementPropertyDefinitionInputV2
 });
-var DTOPropertyDefinitionUpdateActionInputV2 = z164.object({
-  type: z164.literal("PropertyDefinitionUpdate"),
+var DTOPropertyDefinitionUpdateActionInputV2 = z170.object({
+  type: z170.literal("PropertyDefinitionUpdate"),
   input: DTOUpdateElementPropertyDefinitionInputV2
 });
-var DTOPropertyDefinitionDeleteActionInputV2 = z164.object({
-  type: z164.literal("PropertyDefinitionDelete"),
+var DTOPropertyDefinitionDeleteActionInputV2 = z170.object({
+  type: z170.literal("PropertyDefinitionDelete"),
   input: DTODeleteElementPropertyDefinitionInputV2
 });
 
 // src/api/dto/elements/properties/property-values.ts
-import { z as z165 } from "zod";
-var DTOElementPropertyValue = z165.object({
-  id: z165.string(),
-  designSystemVersionId: z165.string(),
-  definitionId: z165.string(),
-  targetElementId: z165.string(),
-  value: z165.union([z165.string(), z165.number(), z165.boolean()]).optional(),
-  valuePreview: z165.string().optional()
+import { z as z171 } from "zod";
+var DTOElementPropertyValue = z171.object({
+  id: z171.string(),
+  designSystemVersionId: z171.string(),
+  definitionId: z171.string(),
+  targetElementId: z171.string(),
+  value: z171.union([z171.string(), z171.number(), z171.boolean()]).optional(),
+  valuePreview: z171.string().optional()
 });
-var DTOElementPropertyValuesGetResponse = z165.object({
-  values: z165.array(DTOElementPropertyValue)
+var DTOElementPropertyValuesGetResponse = z171.object({
+  values: z171.array(DTOElementPropertyValue)
 });
 
 // src/api/dto/elements/elements-action-v2.ts
-import { z as z166 } from "zod";
-var DTOElementActionOutput = z166.discriminatedUnion("type", [
+import { z as z172 } from "zod";
+var DTOElementActionOutput = z172.discriminatedUnion("type", [
   // Documentation pages
   DTODocumentationPageCreateActionOutputV2,
   DTODocumentationPageUpdateActionOutputV2,
@@ -4628,7 +4733,7 @@ var DTOElementActionOutput = z166.discriminatedUnion("type", [
   DTOPropertyDefinitionUpdateActionOutputV2,
   DTOPropertyDefinitionDeleteActionOutputV2
 ]);
-var DTOElementActionInput = z166.discriminatedUnion("type", [
+var DTOElementActionInput = z172.discriminatedUnion("type", [
   // Documentation pages
   DTODocumentationPageCreateActionInputV2,
   DTODocumentationPageUpdateActionInputV2,
@@ -4652,72 +4757,72 @@ var DTOElementActionInput = z166.discriminatedUnion("type", [
 ]);
 
 // src/api/dto/elements/get-elements-v2.ts
-import { z as z167 } from "zod";
-var DTOElementsGetTypeFilter = z167.enum(["FigmaNode"]);
-var DTOElementsGetQuerySchema = z167.object({
-  types: z167.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
+import { z as z173 } from "zod";
+var DTOElementsGetTypeFilter = z173.enum(["FigmaNode"]);
+var DTOElementsGetQuerySchema = z173.object({
+  types: z173.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
 });
-var DTOElementsGetOutput = z167.object({
-  figmaNodes: z167.array(DTOFigmaNode).optional()
+var DTOElementsGetOutput = z173.object({
+  figmaNodes: z173.array(DTOFigmaNode).optional()
 });
 
 // src/api/dto/workspaces/integrations.ts
-import { z as z168 } from "zod";
-var DTOIntegration = z168.object({
-  id: z168.string(),
-  workspaceId: z168.string(),
+import { z as z174 } from "zod";
+var DTOIntegration = z174.object({
+  id: z174.string(),
+  workspaceId: z174.string(),
   type: IntegrationType,
-  createdAt: z168.coerce.date(),
-  integrationCredentials: z168.array(IntegrationCredentialsSchema).optional()
+  createdAt: z174.coerce.date(),
+  integrationCredentials: z174.array(IntegrationCredentials).optional()
 });
-var DTOIntegrationOAuthGetResponse = z168.object({
-  url: z168.string()
+var DTOIntegrationOAuthGetResponse = z174.object({
+  url: z174.string()
 });
-var DTOIntegrationPostResponse = z168.object({
+var DTOIntegrationPostResponse = z174.object({
   integration: DTOIntegration
 });
-var DTOIntegrationsGetListResponse = z168.object({
+var DTOIntegrationsGetListResponse = z174.object({
   integrations: DTOIntegration.array()
 });
 
 // src/api/dto/workspaces/membership.ts
-import { z as z171 } from "zod";
+import { z as z177 } from "zod";
 
 // src/api/dto/workspaces/workspace.ts
-import { z as z170 } from "zod";
+import { z as z176 } from "zod";
 
 // src/api/dto/workspaces/npm-registry.ts
-import { z as z169 } from "zod";
-var DTONpmRegistryConfig = z169.object({
+import { z as z175 } from "zod";
+var DTONpmRegistryConfig = z175.object({
   // Registry basic configuration
   registryType: NpmRegistryType,
-  registryUrl: z169.string(),
-  customRegistryUrl: z169.string().optional(),
+  registryUrl: z175.string(),
+  customRegistryUrl: z175.string().optional(),
   // URL of Supernova NPM packages proxy
-  proxyUrl: z169.string(),
+  proxyUrl: z175.string(),
   // Auth configuration
   authType: NpmRegistryAuthType,
-  accessToken: z169.literal("redacted").optional(),
-  username: z169.string().optional(),
-  password: z169.literal("redacted").optional(),
+  accessToken: z175.literal("redacted").optional(),
+  username: z175.string().optional(),
+  password: z175.literal("redacted").optional(),
   // NPM package scopes for whih the proxy should be enabled
-  enabledScopes: z169.array(z169.string()),
+  enabledScopes: z175.array(z175.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: z169.boolean()
+  bypassProxy: z175.boolean()
 });
 
 // src/api/dto/workspaces/workspace.ts
-var DTOWorkspace = z170.object({
-  id: z170.string(),
+var DTOWorkspace = z176.object({
+  id: z176.string(),
   profile: WorkspaceProfile,
   subscription: Subscription,
   npmRegistry: DTONpmRegistryConfig.optional()
 });
 
 // src/api/dto/workspaces/membership.ts
-var DTOWorkspaceRole = z171.enum(["Owner", "Admin", "Creator", "Viewer", "Billing"]);
-var DTOUserWorkspaceMembership = z171.object({
+var DTOWorkspaceRole = z177.enum(["Owner", "Admin", "Creator", "Viewer", "Billing"]);
+var DTOUserWorkspaceMembership = z177.object({
   // Workspace the user is a member of
   workspace: DTOWorkspace,
   // Assigned role the user has in the workspace
@@ -4727,95 +4832,8 @@ var DTOUserWorkspaceMembership = z171.object({
   // when a workspace's subscription is downgraded to free tier
   effectiveRole: DTOWorkspaceRole
 });
-var DTOUserWorkspaceMembershipsResponse = z171.object({
-  membership: z171.array(DTOUserWorkspaceMembership)
-});
-
-// src/api/payloads/design-systems/brand.ts
-import { z as z172 } from "zod";
-var DTOCreateBrandInput = z172.object({
-  persistentId: z172.string().uuid(),
-  meta: z172.object({
-    name: z172.string(),
-    description: z172.string()
-  })
-});
-
-// src/api/payloads/design-systems/version.ts
-import { z as z173 } from "zod";
-function validateSemver(version) {
-  const semverRegex = /^(\d+)(\.\d+)?(\.\d+)?$/;
-  return semverRegex.test(version);
-}
-var DTOCreateVersionInput = z173.object({
-  meta: ObjectMeta,
-  version: z173.string().refine(validateSemver, {
-    message: "Invalid semantic versioning format"
-  }),
-  changeLog: z173.string()
-});
-
-// src/api/payloads/documentation/block-definitions.ts
-import { z as z174 } from "zod";
-var DTOGetBlockDefinitionsOutput = z174.object({
-  definitions: z174.array(PageBlockDefinition)
-});
-
-// src/api/payloads/liveblocks/auth.ts
-import { z as z175 } from "zod";
-var DTOLiveblocksAuthRequest = z175.object({
-  room: z175.string().optional()
-});
-
-// src/api/payloads/workspaces/workspace-configuration.ts
-import { z as z176 } from "zod";
-var prohibitedSsoKeys = ["providerId", "metadataXml", "emailDomains"];
-function validateSsoPayload(ssoPayload) {
-  const keys = [];
-  let valid = true;
-  if (!ssoPayload) {
-    valid = true;
-    return {
-      valid,
-      keys: []
-    };
-  }
-  for (const key of Object.keys(ssoPayload)) {
-    if (prohibitedSsoKeys.includes(key)) {
-      keys.push(key);
-      valid = false;
-    }
-  }
-  return {
-    valid,
-    keys
-  };
-}
-var NpmRegistryInput = z176.object({
-  enabledScopes: z176.array(z176.string()),
-  customRegistryUrl: z176.string().optional(),
-  bypassProxy: z176.boolean().optional(),
-  npmProxyRegistryConfigId: z176.string().optional(),
-  npmProxyVersion: z176.number().optional(),
-  registryType: z176.string(),
-  authType: z176.string(),
-  authHeaderName: z176.string(),
-  authHeaderValue: z176.string(),
-  accessToken: z176.string(),
-  username: z176.string(),
-  password: z176.string()
-});
-var WorkspaceConfigurationPayload = z176.object({
-  ipWhitelist: WorkspaceIpSettings.partial().optional(),
-  sso: SsoProvider.partial().optional(),
-  npmRegistrySettings: NpmRegistryInput.partial().optional(),
-  profile: WorkspaceProfile.partial().optional()
-});
-
-// src/api/payloads/workspaces/workspace-integrations.ts
-import { z as z177 } from "zod";
-var DTOWorkspaceIntegrationOauthInput = z177.object({
-  type: IntegrationType
+var DTOUserWorkspaceMembershipsResponse = z177.object({
+  membership: z177.array(DTOUserWorkspaceMembership)
 });
 
 // src/yjs/design-system-content/documentation-hierarchy.ts
@@ -8556,6 +8574,7 @@ export {
   DTODeleteElementPropertyDefinitionInputV2,
   DTODesignSystem,
   DTODesignSystemVersion,
+  DTODesignSystemVersionCreationResponse,
   DTODesignSystemVersionGetResponse,
   DTODesignSystemVersionsListResponse,
   DTODocumentationGroupCreateActionInputV2,
@@ -8647,35 +8666,39 @@ export {
   DTOUserWorkspaceMembershipsResponse,
   DTOWorkspace,
   DTOWorkspaceIntegrationOauthInput,
+  DTOWorkspaceIntegrationPATInput,
   DTOWorkspaceRole,
   DocumentationHierarchySettings,
   DocumentationPageEditorModel,
   DocumentationPageV1DTO,
   ListTreeBuilder,
   NpmRegistryInput,
+  ObjectMeta2 as ObjectMeta,
   PageBlockEditorModel,
   PageSectionEditorModel,
+  VersionSQSPayload,
   WorkspaceConfigurationPayload,
+  applyPrivacyConfigurationToNestedItems,
   blockToProsemirrorNode,
   buildDocPagePublishPaths,
   calculateElementParentChain,
-  designSystemBrandToDto,
-  designSystemVersionToDto,
   documentationElementsToHierarchyDto,
   documentationHierarchyToYjs,
   documentationItemConfigurationToDTOV1,
   documentationItemConfigurationToDTOV2,
+  documentationPagesFixedConfigurationToDTOV1,
+  documentationPagesFixedConfigurationToDTOV2,
   documentationPagesToDTOV1,
   documentationPagesToDTOV2,
   documentationPagesToStructureDTOV2,
-  dtoDefaultItemConfigurationV1,
   elementGroupsToDocumentationGroupDTOV1,
   elementGroupsToDocumentationGroupDTOV2,
+  elementGroupsToDocumentationGroupFixedConfigurationDTOV1,
+  elementGroupsToDocumentationGroupFixedConfigurationDTOV2,
   elementGroupsToDocumentationGroupStructureDTOV1,
   elementGroupsToDocumentationGroupStructureDTOV2,
-  elementPropertyDefinitionToDto,
-  elementPropertyValueToDto,
-  elementViewToDto,
+  getDtoDefaultItemConfigurationV1,
+  getDtoDefaultItemConfigurationV2,
   getMockPageBlockDefinitions,
   integrationToDto,
   itemConfigurationToYjs,