@supernova-studio/client 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -249,6 +249,9 @@ var Asset = z13.object({
   properties: AssetProperties.nullish(),
   origin: AssetOrigin.nullish()
 });
+function isImportedAsset(asset) {
+  return !!asset.origin;
+}
 
 // ../model/src/dsm/data-sources/data-source.ts
 import { z as z14 } from "zod";
@@ -501,6 +504,9 @@ var DesignElementType = DesignTokenType.or(
     "PageBlock"
   ])
 );
+function isTokenType(type) {
+  return DesignTokenType.safeParse(type).success;
+}
 var DesignElementCategory = z27.enum([
   "Token",
   "Component",
@@ -856,10 +862,18 @@ var PageBlockV1 = PageBlockBaseV1.extend({
     () => PageBlockV1.array().nullish().transform((t) => t ?? [])
   )
 });
+function traversePageBlocksV1(blocks2, action) {
+  for (const block of blocks2) {
+    action(block);
+    traversePageBlocksV1(block.children, action);
+  }
+}
 
 // ../model/src/dsm/elements/data/documentation-block-v2.ts
 import { z as z33 } from "zod";
-var PageBlockLinkType = z33.enum(["Page", "PageHeading", "Group", "Url"]);
+var PageBlockLinkType = z33.enum(["DocumentationItem", "PageHeading", "Url"]);
+var PageBlockImageType = z33.enum(["Upload", "Asset", "FigmaFrame"]);
+var PageBlockImageAlignment = z33.enum(["Left", "Center", "Stretch"]);
 var PageBlockAppearanceV2 = z33.object({
   itemBackgroundColor: ColorValue
 });
@@ -870,6 +884,11 @@ var PageBlockItemRichTextPropertyValue = z33.object({
   value: PageBlockText,
   calloutType: PageBlockCalloutType.optional()
 });
+var PageBlockItemEmbedPropertyValue = z33.object({
+  value: z33.string().optional(),
+  caption: z33.string().optional(),
+  height: z33.number().optional()
+});
 var PageBlockItemMultiRichTextPropertyValue = z33.object({
   value: PageBlockText.array()
 });
@@ -877,11 +896,26 @@ var PageBlockItemTextPropertyValue = z33.object({
   value: z33.string(),
   calloutType: PageBlockCalloutType.optional()
 });
+var PageBlockItemImageReference = z33.object({
+  type: PageBlockImageType,
+  url: z33.string(),
+  assetId: z33.string().optional(),
+  size: Size.optional(),
+  figmaFile: z33.object({
+    sourceId: z33.string(),
+    frameId: z33.string()
+  }).optional()
+});
+var PageBlockItemImageValue = z33.object({
+  alt: z33.string().optional(),
+  caption: z33.string().optional(),
+  alignment: PageBlockImageAlignment.optional(),
+  value: PageBlockItemImageReference.optional()
+});
 var PageBlockLinkV2 = z33.object({
   type: PageBlockLinkType,
-  pageId: z33.string().optional(),
+  documentationItemId: z33.string().optional(),
   pageHeadingId: z33.string().optional(),
-  groupId: z33.string().optional(),
   url: z33.string().optional(),
   openInNewTab: z33.boolean().optional()
 });
@@ -959,6 +993,16 @@ var FigmaFileStructureElementData = z38.object({
     assetsInFile: FigmaFileStructureStatistics
   })
 });
+function figmaFileStructureToMap(root) {
+  const map = /* @__PURE__ */ new Map();
+  recursiveFigmaFileStructureToMap(root, map);
+  return map;
+}
+function recursiveFigmaFileStructureToMap(node, map) {
+  map.set(node.id, node);
+  for (const child of node.children)
+    recursiveFigmaFileStructureToMap(child, map);
+}
 
 // ../model/src/dsm/elements/data/figma-node-reference.ts
 import { z as z39 } from "zod";
@@ -1199,6 +1243,9 @@ var Component = DesignElementBase.extend(DesignElementGroupableRequiredPart.shap
   svg: ComponentAsset.optional(),
   isAsset: z60.boolean()
 });
+function isImportedComponent(component) {
+  return !!component.origin;
+}
 
 // ../model/src/dsm/elements/documentation-page-v1.ts
 import { z as z61 } from "zod";
@@ -1237,6 +1284,12 @@ var FigmaFileStructure = DesignElementBase.extend({
   origin: FigmaFileStructureOrigin,
   data: FigmaFileStructureData
 });
+function traverseStructure(node, action) {
+  action(node);
+  for (const child of node.children) {
+    traverseStructure(child, action);
+  }
+}
 
 // ../model/src/dsm/elements/figma-node-reference.ts
 var FigmaNodeReference = DesignElementBase.extend({
@@ -1431,6 +1484,21 @@ var DesignTokenTypedData = z66.discriminatedUnion("type", [
 ]);
 var DesignToken = DesignTokenTypedData.and(DesignTokenBase);
 var CreateDesignToken = DesignTokenTypedData.and(CreateDesignTokenBase);
+function extractTokenTypedData(source) {
+  return {
+    type: source.type,
+    data: source.data
+  };
+}
+function isImportedDesignToken(designToken) {
+  return !!designToken.origin;
+}
+function isDesignTokenOfType(designToken, type) {
+  return designToken.type === type;
+}
+function designTokenTypeFilter(type) {
+  return (designToken) => isDesignTokenOfType(designToken, type);
+}
 
 // ../model/src/dsm/elements/theme.ts
 var ThemeOverrideOriginPart = DesignTokenOriginPart;
@@ -1650,6 +1718,12 @@ var DesignTokenImportModelInputBase = ImportModelInputBase.extend(DesignTokenImp
 });
 var DesignTokenImportModel = DesignTokenTypedData.and(DesignTokenImportModelBase);
 var DesignTokenImportModelInput = DesignTokenTypedData.and(DesignTokenImportModelInputBase);
+function isDesignTokenImportModelOfType(designToken, type) {
+  return designToken.type === type;
+}
+function designTokenImportModelTypeFilter(type) {
+  return (designToken) => isDesignTokenImportModelOfType(designToken, type);
+}
 
 // ../model/src/dsm/import/figma-frames.ts
 import { z as z75 } from "zod";
@@ -1673,6 +1747,16 @@ var FigmaFileStructureImportModelInput = ImportModelInputBase.extend(
 ).extend({
   fileVersionId: z75.string()
 });
+function figmaFileStructureImportModelToMap(root) {
+  const map = /* @__PURE__ */ new Map();
+  recursiveFigmaFileStructureToMap2(root, map);
+  return map;
+}
+function recursiveFigmaFileStructureToMap2(node, map) {
+  map.set(node.id, node);
+  for (const child of node.children)
+    recursiveFigmaFileStructureToMap2(child, map);
+}
 
 // ../model/src/dsm/import/data-source.ts
 import { z as z76 } from "zod";
@@ -1700,6 +1784,16 @@ var ImportModelCollection = z77.object({
   themes: z77.array(ThemeImportModel).default([]),
   figmaFileStructures: z77.array(FigmaFileStructureImportModel)
 });
+function addImportModelCollections(lhs, rhs) {
+  return {
+    sources: [...lhs.sources, ...rhs.sources],
+    tokens: [...lhs.tokens, ...rhs.tokens],
+    components: [...lhs.components, ...rhs.components],
+    themeUpdates: [...lhs.themeUpdates, ...rhs.themeUpdates],
+    themes: [...lhs.themes, ...rhs.themes],
+    figmaFileStructures: [...lhs.figmaFileStructures, ...rhs.figmaFileStructures]
+  };
+}
 
 // ../model/src/dsm/import/warning.ts
 import { z as z78 } from "zod";
@@ -1837,7 +1931,8 @@ var PageBlockDefinitionPropertyType = z82.enum([
   "CodeSandbox",
   "Table",
   "Divider",
-  "Storybook"
+  "Storybook",
+  "Color"
 ]);
 var PageBlockDefinitionRichTextPropertyStyle = z82.enum([
   "Title1",
@@ -2196,6 +2291,14 @@ var DesignSystemUpdateInput = z97.object({
   docExporterId: z97.string().optional()
 });
 
+// ../model/src/dsm/published-doc-page.ts
+var SHORT_PERSISTENT_ID_LENGTH = 8;
+function tryParseShortPersistentId(url = "/") {
+  const lastUrlPart = url.split("/").pop() || "";
+  const shortPersistentId = lastUrlPart.split("-").pop()?.replaceAll(".html", "") || null;
+  return shortPersistentId?.length === SHORT_PERSISTENT_ID_LENGTH ? shortPersistentId : null;
+}
+
 // ../model/src/dsm/published-doc.ts
 import { z as z98 } from "zod";
 var publishedDocEnvironments = ["Live", "Preview"];
@@ -3879,6 +3982,11 @@ var BlockParsingUtils = {
     const richText = PageBlockItemMultiRichTextPropertyValue.parse(objectValue);
     return richText;
   },
+  embedPropertyValue(item, propertyKey) {
+    const objectValue = this.objectPropertyValue(item, propertyKey);
+    const embed = PageBlockItemEmbedPropertyValue.parse(objectValue);
+    return embed;
+  },
   objectPropertyValue(item, propertyKey) {
     const value = this.propertyValueOrThrow(item, propertyKey);
     if (typeof value !== "object") {
@@ -3912,6 +4020,12 @@ var BlockDefinitionUtils = {
       return property;
     return void 0;
   },
+  firstEmbedProperty(definition) {
+    const property = definition.item.properties.find((p) => p.type === "EmbedURL");
+    if (property)
+      return property;
+    return void 0;
+  },
   richTextProperty(definition, propertyKey) {
     return this.property(definition, propertyKey, "RichText");
   },
@@ -3967,6 +4081,24 @@ function blockToProsemirrorNode(block, definition) {
       property: multiRichTextProperty
     });
   }
+  const embedProperty = BlockDefinitionUtils.firstEmbedProperty(definition);
+  const embedType = serializeEmbedType(block.data.packageId);
+  if (embedProperty && embedType) {
+    return serializeAsEmbed(
+      {
+        block,
+        definition,
+        property: embedProperty
+      },
+      embedType
+    );
+  }
+  if (block.data.packageId === "io.supernova.block.divider") {
+    return serializeAsDivider({
+      block,
+      definition
+    });
+  }
   return serializeAsCustomBlock(block, definition);
 }
 function serializeAsRichTextBlock(input) {
@@ -4079,6 +4211,38 @@ function serializeAsListItem(text) {
     ]
   };
 }
+function serializeAsEmbed(input, embedType) {
+  const { block, definition, property: embedProperty } = input;
+  const blockItem = BlockParsingUtils.singleBlockItem(block);
+  const embedValue = BlockParsingUtils.embedPropertyValue(blockItem, embedProperty.id);
+  return {
+    type: "embed",
+    attrs: {
+      ...serializeBlockNodeAttributes(input),
+      type: embedType,
+      url: embedValue.value,
+      height: embedValue.height,
+      caption: embedValue.caption
+    }
+  };
+}
+function serializeEmbedType(blockDefinitionId) {
+  switch (blockDefinitionId) {
+    case "io.supernova.block.embed":
+      return "generic";
+    case "io.supernova.block.embed-youtube":
+      return "youtube";
+    case "io.supernova.block.embed-figma":
+      return "figma";
+  }
+  return void 0;
+}
+function serializeAsDivider(input) {
+  return {
+    type: "horizontalrule",
+    attrs: serializeBlockNodeAttributes(input)
+  };
+}
 function serializeBlockNodeAttributes(input) {
   const { block } = input;
   return {
@@ -4171,43 +4335,23 @@ function serializeTextSpanAttribute(spanAttribute) {
   }
 }
 function serializeAsCustomBlock(block, definition) {
-  const items = block.data.items.map((i) => serializeItem(i, block, definition));
+  const items = block.data.items.map((i) => {
+    return {
+      id: i.id,
+      props: i.props,
+      linksTo: i.linksTo
+    };
+  });
   return {
     type: "blockNode",
     attrs: {
       id: block.id,
       definitionId: block.data.packageId,
-      variantId: "default",
-      columns: 1,
+      variantId: block.data.variantId,
       items: JSON.stringify(items)
-      // TODO Docs: variant, columns
     }
   };
 }
-function serializeItem(item, block, definition) {
-  const result = {
-    properties: []
-  };
-  for (const property of definition.item.properties) {
-    const serializedValue = serializePropertyValue(item, property);
-    serializedValue && result.properties.push(serializedValue);
-  }
-  return result;
-}
-function serializePropertyValue(item, property) {
-  const value = item.props[property.id] ?? void 0;
-  if (!value) {
-    return void 0;
-  }
-  const result = {
-    id: property.id,
-    data: {}
-  };
-  if (typeof value === "string") {
-    result.data.value = value;
-  }
-  return result;
-}
 function nonNullFilter(item) {
   return !!item;
 }
@@ -4801,7 +4945,7 @@ var blocks = [
         {
           id: "block.links.property.title",
           name: "Title",
-          type: "RichText",
+          type: "Text",
           description: void 0,
           options: { textStyle: "Title5" },
           variantOptions: void 0
@@ -4809,7 +4953,7 @@ var blocks = [
         {
           id: "block.links.property.description",
           name: "Short description",
-          type: "RichText",
+          type: "Text",
           description: void 0,
           options: { textStyle: "Default", color: "NeutralFaded" },
           variantOptions: void 0
@@ -5603,24 +5747,86 @@ function prosemirrorNodeToBlock(prosemirrorNode, definition) {
   if (richTextProperty) {
     return parseAsRichText(prosemirrorNode, definition, richTextProperty);
   }
+  const multiRichTextProperty = BlockDefinitionUtils.firstMultiRichTextProperty(definition);
+  if (multiRichTextProperty) {
+    return parseAsMultiRichText(prosemirrorNode, definition, multiRichTextProperty);
+  }
+  const embedProperty = BlockDefinitionUtils.firstEmbedProperty(definition);
+  if (prosemirrorNode.type === "embed" && embedProperty) {
+    return parseAsEmbed(prosemirrorNode, definition, embedProperty);
+  }
+  if (definition.id === "io.supernova.block.divider") {
+    return parseAsDivider(prosemirrorNode, definition);
+  }
   return parseAsCustomBlock(prosemirrorNode, definition);
 }
 function parseAsRichText(prosemirrorNode, definition, property) {
   const id = parseProsemirrorBlockAttribute(prosemirrorNode, "id");
   const variantId = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "variantId");
+  const calloutType = parseCalloutType(parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "type"));
   return {
     // TODO Artem: indent
     id,
+    ...variantId && { variantId },
     data: {
       packageId: definition.id,
       indentLevel: 0,
-      variantId,
       items: [
         {
           id,
           props: {
             [property.id]: {
-              value: parseRichText(prosemirrorNode.content ?? [])
+              // Required
+              value: parseRichText(prosemirrorNode.content ?? []),
+              // Optional
+              ...calloutType && { calloutType }
+            }
+          }
+        }
+      ]
+    }
+  };
+}
+function parseCalloutType(prosemirrorCalloutType) {
+  if (!prosemirrorCalloutType)
+    return void 0;
+  switch (prosemirrorCalloutType) {
+    case "error":
+      return "Error";
+    case "neutral":
+      return "Info";
+    case "success":
+      return "Success";
+    case "warning":
+      return "Warning";
+  }
+}
+function parseAsMultiRichText(prosemirrorNode, definition, property) {
+  const id = parseProsemirrorBlockAttribute(prosemirrorNode, "id");
+  const variantId = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "variantId");
+  return {
+    // TODO Artem: indent
+    id,
+    data: {
+      packageId: definition.id,
+      indentLevel: 0,
+      ...variantId && { variantId },
+      items: [
+        {
+          id,
+          props: {
+            [property.id]: {
+              // Required
+              value: (prosemirrorNode.content ?? []).map((listItem) => {
+                if (listItem.type !== "listitem")
+                  return null;
+                if (!listItem.content?.length)
+                  return parseRichText([]);
+                const paragraph = listItem.content[0];
+                if (paragraph.type !== "paragraph")
+                  return parseRichText([]);
+                return parseRichText(paragraph.content ?? []);
+              }).filter(nonNullFilter2)
             }
           }
         }
@@ -5664,8 +5870,97 @@ function parseRichTextAttribute(mark) {
   }
   return null;
 }
+function parseAsEmbed(prosemirrorNode, definition, property) {
+  const id = parseProsemirrorBlockAttribute(prosemirrorNode, "id");
+  const variantId = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "variantId");
+  const url = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "url");
+  const caption = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "caption");
+  const height = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "height");
+  return {
+    id,
+    data: {
+      packageId: definition.id,
+      indentLevel: 0,
+      ...variantId && { variantId },
+      items: [
+        {
+          id,
+          props: {
+            [property.id]: {
+              value: url,
+              caption,
+              height
+            }
+          }
+        }
+      ]
+    }
+  };
+}
+function parseAsDivider(prosemirrorNode, definition) {
+  const id = parseProsemirrorBlockAttribute(prosemirrorNode, "id");
+  const variantId = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "variantId");
+  return {
+    id,
+    data: {
+      packageId: definition.id,
+      indentLevel: 0,
+      ...variantId && { variantId },
+      items: [{ id, props: {} }]
+    }
+  };
+}
 function parseAsCustomBlock(prosemirrorNode, definition) {
-  return null;
+  const id = parseProsemirrorBlockAttribute(prosemirrorNode, "id");
+  const variantId = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "variantId");
+  const itemsString = parseProsemirrorBlockAttribute(prosemirrorNode, "items");
+  const itemsJson = JSON.parse(itemsString);
+  if (!Array.isArray(itemsJson)) {
+    console.error("Block `items` property must be a json array");
+    return null;
+  }
+  const parsedItems = itemsJson.map((i) => parseItem(i, definition));
+  return {
+    id,
+    data: {
+      packageId: definition.id,
+      indentLevel: 0,
+      ...variantId && { variantId },
+      items: parsedItems
+    }
+  };
+}
+function parseItem(rawItem, definition) {
+  const parsedItem = PageBlockItemV2.safeParse(rawItem);
+  if (!parsedItem.success) {
+    return null;
+  }
+  const sanitizedProps = {};
+  for (const property of definition.item.properties) {
+    const value = parsedItem.data.props[property.id];
+    if (!value) {
+      return null;
+    }
+    switch (property.type) {
+      case "Text":
+        PageBlockItemTextPropertyValue.parse(value);
+        break;
+      case "EmbedURL":
+        PageBlockItemEmbedPropertyValue.parse(value);
+        break;
+      case "Image":
+        PageBlockItemImageValue.parse(value);
+        break;
+      default:
+        return null;
+    }
+    sanitizedProps[property.id] = value;
+  }
+  return {
+    id: parsedItem.data.id,
+    linksTo: parsedItem.data.linksTo,
+    props: sanitizedProps
+  };
 }
 function parseProsemirrorBlockAttribute(prosemirrorNode, attributeName) {
   const attributeValue = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, attributeName);
@@ -5688,22 +5983,433 @@ function mapByUnique(items, keyFn) {
   return result;
 }
 export {
+  Address,
+  Asset,
+  AssetFontProperties,
+  AssetImportModelInput,
+  AssetOrigin,
+  AssetProperties,
+  AssetReference,
+  AssetScope,
+  AssetType,
+  AssetValue,
+  AuthTokens,
+  BasePulsarProperty,
+  BillingDetails,
+  BillingIntervalSchema,
+  BillingType,
+  BillingTypeSchema,
   BlockDefinitionUtils,
   BlockParsingUtils,
+  BlurTokenData,
+  BlurType,
+  BlurValue,
+  BorderPosition,
+  BorderRadiusTokenData,
+  BorderRadiusUnit,
+  BorderRadiusValue,
+  BorderStyle,
+  BorderTokenData,
+  BorderValue,
+  BorderWidthTokenData,
+  BorderWidthUnit,
+  BorderWidthValue,
+  BrandedElementGroup,
+  CardSchema,
+  ChangedImportedFigmaSourceData,
+  ColorTokenData,
+  ColorTokenInlineData,
+  ColorValue,
+  Component,
+  ComponentElementData,
+  ComponentImportModel,
+  ComponentImportModelInput,
+  ComponentOrigin,
+  ComponentOriginPart,
+  ContentLoadInstruction,
+  ContentLoaderPayload,
+  CreateDesignToken,
+  CreateWorkspaceInput,
+  CustomDomain,
+  Customer,
+  DataSourceAutoImportMode,
+  DataSourceFigmaFileData,
+  DataSourceFigmaFileVersionData,
+  DataSourceFigmaImportMetadata,
+  DataSourceFigmaRemote,
+  DataSourceFigmaScope,
+  DataSourceFigmaState,
+  DataSourceImportModel,
+  DataSourceRemote,
+  DataSourceRemoteType,
+  DataSourceStats,
+  DataSourceTokenStudioRemote,
+  DataSourceUploadImportMetadata,
+  DataSourceUploadRemote,
+  DataSourceUploadRemoteSource,
+  DataSourceVersion,
+  DesignElement,
+  DesignElementBase,
+  DesignElementBrandedPart,
+  DesignElementCategory,
+  DesignElementGroupableBase,
+  DesignElementGroupablePart,
+  DesignElementGroupableRequiredPart,
+  DesignElementImportedBase,
+  DesignElementOrigin,
+  DesignElementSlugPart,
+  DesignElementType,
+  DesignSystem,
+  DesignSystemCreateInput,
+  DesignSystemElementExportProps,
+  DesignSystemSwitcher,
+  DesignSystemUpdateInput,
+  DesignSystemVersionRoom,
+  DesignSystemWithWorkspace,
+  DesignToken,
+  DesignTokenImportModel,
+  DesignTokenImportModelBase,
+  DesignTokenImportModelInput,
+  DesignTokenImportModelInputBase,
+  DesignTokenOrigin,
+  DesignTokenOriginPart,
+  DesignTokenType,
+  DesignTokenTypedData,
+  DimensionTokenData,
+  DimensionUnit,
+  DimensionValue,
+  DocumentationGroupBehavior,
+  DocumentationGroupDTO,
+  DocumentationItemConfiguration,
+  DocumentationPage,
+  DocumentationPageDTOV1,
+  DocumentationPageDataV1,
+  DocumentationPageDataV2,
   DocumentationPageEditorModel,
+  DocumentationPageElementDataV1,
+  DocumentationPageElementDataV2,
+  DocumentationPageGroup,
+  DocumentationPageRoom,
+  DocumentationPageV1,
+  DocumentationPageV2,
+  DurationTokenData,
+  DurationUnit,
+  DurationValue,
+  ElementGroup,
+  ElementGroupData,
+  ElementGroupElementData,
+  ElementPropertyDefinition,
+  ElementPropertyDefinitionOption,
+  ElementPropertyLinkType,
+  ElementPropertyTargetType,
+  ElementPropertyType,
+  ElementPropertyValue,
+  Entity,
+  ExportJob,
+  ExportJobStatus,
+  Exporter,
+  ExporterDetails,
+  ExporterSource,
+  ExporterTag,
+  ExporterType,
+  ExporterWorkspaceMembership,
+  ExporterWorkspaceMembershipRole,
+  ExternalOAuthRequest,
+  ExternalServiceType,
+  FeatureFlag,
+  FeatureFlagMap,
+  FeaturesSummary,
+  FigmaFileAccessData,
+  FigmaFileDownloadScope,
+  FigmaFileStructure,
+  FigmaFileStructureData,
+  FigmaFileStructureElementData,
+  FigmaFileStructureImportModel,
+  FigmaFileStructureImportModelInput,
+  FigmaFileStructureNode,
+  FigmaFileStructureNodeBase,
+  FigmaFileStructureNodeImportModel,
+  FigmaFileStructureNodeType,
+  FigmaFileStructureOrigin,
+  FigmaFileStructureStatistics,
+  FigmaImportBaseContext,
+  FigmaImportContextWithDownloadScopes,
+  FigmaNodeReference,
+  FigmaNodeReferenceData,
+  FigmaNodeReferenceElementData,
+  FigmaPngRenderImportModel,
+  FigmaRenderFormat,
+  FigmaRenderImportModel,
+  FigmaSvgRenderImportModel,
+  FileStructureStats,
+  FlaggedFeature,
+  FontFamilyTokenData,
+  FontFamilyValue,
+  FontSizeTokenData,
+  FontSizeUnit,
+  FontSizeValue,
+  FontWeightTokenData,
+  FontWeightValue,
   GetBlockDefinitionsResponse,
+  GitProvider,
+  GitProviderNames,
+  GradientLayerData,
+  GradientLayerValue,
+  GradientStop,
+  GradientTokenData,
+  GradientTokenValue,
+  GradientType,
+  HANDLE_MAX_LENGTH,
+  HANDLE_MIN_LENGTH,
+  ImageImportModel,
+  ImageImportModelType,
+  ImportFunctionInput,
+  ImportJob,
+  ImportJobOperation,
+  ImportJobState,
+  ImportModelBase,
+  ImportModelCollection,
+  ImportModelInputBase,
+  ImportModelInputCollection,
+  ImportWarning,
+  ImportWarningType,
+  ImportedFigmaSourceData,
+  IntegrationAuthType,
+  IntegrationTokenSchema,
+  IntegrationUserInfo,
+  InternalStatus,
+  InternalStatusSchema,
+  InvoiceCouponSchema,
+  InvoiceLineSchema,
+  InvoiceSchema,
+  LetterSpacingTokenData,
+  LetterSpacingUnit,
+  LetterSpacingValue,
+  LineHeightTokenData,
+  LineHeightUnit,
+  LineHeightValue,
+  MAX_MEMBERS_COUNT,
+  NpmPackage,
+  NpmProxyToken,
+  NpmProxyTokenPayload,
+  NpmRegistrCustomAuthConfig,
+  NpmRegistryAuthConfig,
+  NpmRegistryAuthType,
+  NpmRegistryBasicAuthConfig,
+  NpmRegistryBearerAuthConfig,
+  NpmRegistryConfig,
+  NpmRegistryNoAuthConfig,
+  NpmRegistryType,
+  OAuthProvider,
+  OAuthProviderNames,
+  OAuthProviderSchema,
+  ObjectMeta,
+  OpacityTokenData,
+  OpacityValue,
+  PageBlockAlignment,
+  PageBlockAppearanceV2,
+  PageBlockAsset,
+  PageBlockAssetComponent,
+  PageBlockAssetType,
+  PageBlockBehaviorDataType,
+  PageBlockBehaviorSelectionType,
+  PageBlockCalloutType,
+  PageBlockCategory,
+  PageBlockCodeLanguage,
+  PageBlockCustomBlockPropertyImageValue,
+  PageBlockCustomBlockPropertyValue,
+  PageBlockDataV2,
+  PageBlockDefinition,
+  PageBlockDefinitionAppearance,
+  PageBlockDefinitionBehavior,
+  PageBlockDefinitionBooleanPropertyStyle,
+  PageBlockDefinitionItem,
+  PageBlockDefinitionLayout,
+  PageBlockDefinitionLayoutAlign,
+  PageBlockDefinitionLayoutBase,
+  PageBlockDefinitionLayoutGap,
+  PageBlockDefinitionLayoutResizing,
+  PageBlockDefinitionLayoutType,
+  PageBlockDefinitionMultiRichTextPropertyStyle,
+  PageBlockDefinitionMultiSelectPropertyStyle,
+  PageBlockDefinitionOnboarding,
+  PageBlockDefinitionProperty,
+  PageBlockDefinitionPropertyOptions,
+  PageBlockDefinitionPropertyType,
+  PageBlockDefinitionRichTextPropertyStyle,
+  PageBlockDefinitionSingleSelectPropertyStyle,
+  PageBlockDefinitionTextPropertyStyle,
+  PageBlockDefinitionVariant,
   PageBlockEditorModel,
+  PageBlockEditorModelV2,
+  PageBlockFigmaFrameProperties,
+  PageBlockFrame,
+  PageBlockFrameOrigin,
+  PageBlockImageAlignment,
+  PageBlockImageType,
+  PageBlockItemEmbedPropertyValue,
+  PageBlockItemImageReference,
+  PageBlockItemImageValue,
+  PageBlockItemMultiRichTextPropertyValue,
+  PageBlockItemRichTextPropertyValue,
+  PageBlockItemTextPropertyValue,
+  PageBlockItemUntypedPropertyValue,
+  PageBlockItemV2,
+  PageBlockLinkPreview,
+  PageBlockLinkType,
+  PageBlockLinkV2,
+  PageBlockRenderCodeProperties,
+  PageBlockShortcut,
+  PageBlockTableColumn,
+  PageBlockTableProperties,
+  PageBlockText,
+  PageBlockTextSpan,
+  PageBlockTextSpanAttribute,
+  PageBlockTextSpanAttributeType,
+  PageBlockTheme,
+  PageBlockThemeType,
+  PageBlockTilesAlignment,
+  PageBlockTilesLayout,
+  PageBlockTypeV1,
+  PageBlockUrlPreview,
+  PageBlockV1,
+  PageBlockV2,
+  ParagraphIndentTokenData,
+  ParagraphIndentUnit,
+  ParagraphIndentValue,
+  ParagraphSpacingTokenData,
+  ParagraphSpacingUnit,
+  ParagraphSpacingValue,
+  PeriodSchema,
+  PersonalAccessToken,
+  PluginOAuthRequestSchema,
+  Point2D,
+  PostStripeCheckoutBodyInputSchema,
+  PostStripeCheckoutOutputSchema,
+  PostStripePortalSessionBodyInputSchema,
+  PostStripePortalSessionOutputSchema,
+  PostStripePortalUpdateSessionBodyInputSchema,
+  PriceSchema,
+  ProductCode,
+  ProductCodeSchema,
+  ProductCopyTokenData,
+  ProductCopyValue,
+  PublishedDoc,
+  PublishedDocEnvironment,
+  PublishedDocRoutingVersion,
+  PublishedDocsChecksums,
+  PulsarContributionBlock,
+  PulsarContributionConfigurationProperty,
+  PulsarContributionVariant,
+  PulsarPropertyType,
+  SHORT_PERSISTENT_ID_LENGTH,
+  Session,
+  SessionData,
+  ShadowLayerValue,
+  ShadowTokenData,
+  ShadowType,
+  ShallowDesignElement,
+  Size,
+  SizeOrUndefined,
+  SizeTokenData,
+  SizeUnit,
+  SizeValue,
+  SourceImportComponentSummary,
+  SourceImportFrameSummary,
+  SourceImportSummary,
+  SourceImportSummaryByTokenType,
+  SourceImportTokenSummary,
+  SpaceTokenData,
+  SpaceUnit,
+  SpaceValue,
+  SsoProvider,
+  StringTokenData,
+  StringValue,
+  StripeSubscriptionStatus,
+  StripeSubscriptionStatusSchema,
+  Subscription,
+  TextCase,
+  TextCaseTokenData,
+  TextCaseValue,
+  TextDecoration,
+  TextDecorationTokenData,
+  TextDecorationValue,
+  Theme,
+  ThemeElementData,
+  ThemeImportModel,
+  ThemeImportModelInput,
+  ThemeOrigin,
+  ThemeOriginObject,
+  ThemeOriginPart,
+  ThemeOriginSource,
+  ThemeOverride,
+  ThemeOverrideImportModel,
+  ThemeOverrideImportModelBase,
+  ThemeOverrideImportModelInput,
+  ThemeOverrideOrigin,
+  ThemeOverrideOriginPart,
+  ThemeUpdateImportModel,
+  ThemeUpdateImportModelInput,
+  TokenDataAliasSchema,
+  TypographyTokenData,
+  TypographyValue,
+  UrlImageImportModel,
+  User,
+  UserIdentity,
+  UserInvite,
+  UserInvites,
+  UserLinkedIntegrations,
+  UserOnboarding,
+  UserOnboardingDepartment,
+  UserOnboardingJobLevel,
+  UserProfile,
+  UserSession,
+  Visibility,
+  VisibilityTokenData,
+  VisibilityValue,
+  Workspace,
+  WorkspaceContext,
+  WorkspaceInvitation,
+  WorkspaceIpSettings,
+  WorkspaceIpWhitelistEntry,
+  WorkspaceMembership,
+  WorkspaceProfile,
+  WorkspaceRole,
+  WorkspaceRoleSchema,
+  WorkspaceWithDesignSystems,
+  ZIndexTokenData,
+  ZIndexUnit,
+  ZIndexValue,
+  addImportModelCollections,
   blockDefinitionForBlock,
   blockToProsemirrorNode,
+  designTokenImportModelTypeFilter,
+  designTokenTypeFilter,
+  extractTokenTypedData,
+  figmaFileStructureImportModelToMap,
+  figmaFileStructureToMap,
   getMockPageBlockDefinitions,
+  isDesignTokenImportModelOfType,
+  isDesignTokenOfType,
+  isImportedAsset,
+  isImportedComponent,
+  isImportedDesignToken,
+  isTokenType,
+  nullishToOptional,
   pageToProsemirrorDoc,
   pageToYXmlFragment,
   pmSchema,
   prosemirrorDocToPage,
   prosemirrorNodeToBlock,
+  publishedDocEnvironments,
   serializeAsCustomBlock,
-  serializeAsMultiRichTextBlock,
-  serializeAsRichTextBlock,
-  yXmlFragmetToPage
+  tokenAliasOrValue,
+  tokenElementTypes,
+  traversePageBlocksV1,
+  traverseStructure,
+  tryParseShortPersistentId,
+  yXmlFragmetToPage,
+  zodCreateInputOmit,
+  zodUpdateInputOmit
 };
 //# sourceMappingURL=index.mjs.map