@supernova-studio/model 0.0.8 → 0.2.2

package/dist/index.mjs

@@ -0,0 +1,3108 @@
+// src/auth/plugin-oauth-request.ts
+import { z } from "zod";
+var PluginOAuthRequestSchema = z.object({
+  id: z.string(),
+  codeChallenge: z.string(),
+  readKey: z.string(),
+  writeKey: z.string(),
+  readKeyConsumed: z.boolean(),
+  writeKeyConsumed: z.boolean(),
+  oAuthCode: z.string().optional(),
+  createdAt: z.date()
+});
+
+// src/billing/card.ts
+import { z as z2 } from "zod";
+var CardSchema = z2.object({
+  cardId: z2.string().nullish(),
+  last4: z2.string().length(4).nullish(),
+  expiryMonth: z2.string().nullish(),
+  expiryYear: z2.string().nullish(),
+  brand: z2.string().nullish(),
+  name: z2.string().nullish()
+});
+
+// src/billing/checkoutSession.ts
+import { z as z3 } from "zod";
+var PostStripeCheckoutBodyInputSchema = z3.object({
+  priceId: z3.string(),
+  successUrl: z3.string().url(),
+  cancelUrl: z3.string().url(),
+  quantity: z3.number().int().min(1).optional()
+});
+var PostStripeCheckoutOutputSchema = z3.object({
+  id: z3.string(),
+  url: z3.string().nullish()
+});
+
+// src/billing/customer.ts
+import { z as z4 } from "zod";
+var Customer = z4.object({
+  id: z4.string()
+});
+var Address = z4.object({
+  street1: z4.string().optional(),
+  street2: z4.string().optional(),
+  city: z4.string().optional(),
+  postal: z4.string().optional(),
+  country: z4.string().optional(),
+  state: z4.string().optional()
+});
+var BillingDetails = z4.object({
+  address: Address.optional(),
+  email: z4.string().optional(),
+  companyName: z4.string().optional(),
+  companyId: z4.string().optional(),
+  notes: z4.string().optional(),
+  vat: z4.string().optional(),
+  poNumber: z4.string().optional()
+});
+
+// src/billing/features.ts
+import { z as z5 } from "zod";
+var featureLimitedSchema = z5.object({
+  max: z5.number(),
+  errorMessage: z5.string(),
+  errorReason: z5.string()
+});
+var featureToggleSchema = z5.object({
+  enabled: z5.boolean(),
+  errorMessage: z5.string(),
+  errorReason: z5.string()
+});
+var featureWithImportJobsSchema = featureLimitedSchema.extend({
+  noImportJobsErrorMessage: z5.string(),
+  noImportJobsErrorReason: z5.string()
+});
+var FeaturesSummary = z5.object({
+  designSystems: featureLimitedSchema,
+  designSystemSources: featureWithImportJobsSchema,
+  designSystemVersions: featureLimitedSchema,
+  themes: featureLimitedSchema,
+  brands: featureLimitedSchema,
+  codegenSchedules: featureLimitedSchema,
+  publicDocumentation: featureToggleSchema,
+  customDocumentationUrl: featureToggleSchema,
+  customDocumentationViewButton: featureToggleSchema,
+  designSystemSourceAutoImport: featureToggleSchema,
+  designSystemSlug: featureToggleSchema,
+  ipWhitelisting: featureToggleSchema,
+  npmRegistry: featureToggleSchema,
+  sso: featureToggleSchema,
+  workspacePaidSeats: featureLimitedSchema,
+  workspaceViewers: featureLimitedSchema,
+  customDocumentationExporter: featureToggleSchema
+});
+
+// src/billing/invoice.ts
+import { z as z6 } from "zod";
+var InvoiceSchema = z6.object({
+  id: z6.string(),
+  number: z6.string(),
+  amount_due: z6.number(),
+  date: z6.date(),
+  hostedUrl: z6.string().url(),
+  card: CardSchema.nullish()
+});
+var PeriodSchema = z6.object({
+  start: z6.date(),
+  end: z6.date()
+});
+var InvoiceLineSchema = z6.object({
+  amount: z6.number(),
+  period: PeriodSchema,
+  proration: z6.boolean(),
+  description: z6.string(),
+  type: z6.string()
+});
+var InvoiceCouponSchema = z6.object({
+  amount_off: z6.number(),
+  percent_off: z6.number(),
+  name: z6.string()
+});
+
+// src/billing/portalSession.ts
+import { z as z7 } from "zod";
+var PostStripePortalUpdateSessionBodyInputSchema = z7.object({
+  priceId: z7.string(),
+  numberOfSeats: z7.number().int()
+});
+var PostStripePortalSessionBodyInputSchema = z7.object({
+  returnUrl: z7.string().url(),
+  update: PostStripePortalUpdateSessionBodyInputSchema.optional(),
+  cancel: z7.boolean().optional()
+});
+var PostStripePortalSessionOutputSchema = z7.object({
+  id: z7.string(),
+  url: z7.string().nullish()
+});
+
+// src/billing/price.ts
+import { z as z8 } from "zod";
+var BillingIntervalSchema = z8.enum(["daily", "monthly", "weekly", "yearly"]);
+var PriceSchema = z8.object({
+  stripePriceId: z8.string(),
+  stripeProductId: z8.string(),
+  stripeProductName: z8.string().optional(),
+  stripeProductDescription: z8.string().optional(),
+  active: z8.boolean(),
+  amount: z8.number(),
+  interval: BillingIntervalSchema,
+  isPricePerCreator: z8.boolean().optional(),
+  isTrial: z8.boolean().optional(),
+  isHidden: z8.boolean().optional(),
+  minimumSeats: z8.number().optional(),
+  legacyVersion: z8.string().optional(),
+  featuresSet: z8.string().optional(),
+  stripeProductFeatures: z8.array(z8.string()).optional(),
+  stripeProductAdditionalFeatures: z8.array(z8.string()).optional()
+});
+
+// src/billing/product.ts
+import { z as z9 } from "zod";
+var ProductCodeSchema = z9.enum(["free", "team", "team_test", "company", "enterprise"]);
+var ProductCode = ProductCodeSchema.enum;
+
+// src/billing/subscription.ts
+import { z as z10 } from "zod";
+var StripeSubscriptionStatusSchema = z10.enum([
+  "trialing",
+  "active",
+  "past_due",
+  "canceled",
+  "unpaid",
+  "incomplete_expired",
+  "incomplete",
+  "unknown"
+]);
+var InternalStatusSchema = z10.enum(["active", "suspended", "gracePeriod", "cancelled", "downgraded_to_free"]);
+var BillingTypeSchema = z10.enum(["Auto", "Invoice"]);
+var StripeSubscriptionStatus = StripeSubscriptionStatusSchema.enum;
+var InternalStatus = InternalStatusSchema.enum;
+var BillingType = BillingTypeSchema.enum;
+var Subscription = z10.object({
+  stripeSubscriptionId: z10.string().nullish(),
+  stripeCustomerId: z10.string().nullish(),
+  status: InternalStatusSchema.optional(),
+  subscriptionStatus: StripeSubscriptionStatusSchema.optional(),
+  // the stripe API official status
+  internalStatus: InternalStatusSchema.optional(),
+  // TODO: delete when create/get workspace will stop using it in the former API
+  product: ProductCodeSchema,
+  featuresSummary: FeaturesSummary.optional(),
+  stripeProductDescription: z10.string().optional(),
+  stripeProductFeatures: z10.array(z10.string()).optional(),
+  stripeProductAdditionalFeatures: z10.array(z10.string()).optional(),
+  stripeSubscriptionMainItemId: z10.string().optional(),
+  planPriceId: z10.string(),
+  planInterval: BillingIntervalSchema,
+  isPricePerCreator: z10.boolean().optional(),
+  legacyVersion: z10.string().optional(),
+  seats: z10.number(),
+  seatLimit: z10.number(),
+  currentPeriodStart: z10.string().optional(),
+  currentPeriodEnd: z10.string().optional(),
+  subscriptionStatusUpdatedAt: z10.string().optional(),
+  cancelAt: z10.string().nullish(),
+  card: CardSchema.optional(),
+  // New
+  amount: z10.number().nullish(),
+  isTrial: z10.boolean().optional(),
+  billingType: BillingTypeSchema.optional(),
+  daysUntilDue: z10.number().optional()
+});
+
+// src/dsm/assets/asset-reference.ts
+import { z as z11 } from "zod";
+var AssetReference = z11.object({
+  id: z11.string(),
+  designSystemVersionId: z11.string(),
+  assetId: z11.string(),
+  persistentId: z11.string()
+});
+
+// src/dsm/assets/asset-value.ts
+import { z as z12 } from "zod";
+var AssetValue = z12.object({});
+
+// src/dsm/assets/asset.ts
+import { z as z13 } from "zod";
+var AssetType = z13.enum(["Image", "Font"]);
+var AssetScope = z13.enum(["DocumentationFrame", "ComponentThumbnail", "DesignSystem", "Documentation"]);
+var AssetFontProperties = z13.object({
+  family: z13.string(),
+  subfamily: z13.string()
+});
+var AssetProperties = z13.object({
+  fontProperties: z13.array(AssetFontProperties)
+});
+var AssetOrigin = z13.object({
+  originKey: z13.string()
+});
+var Asset = z13.object({
+  id: z13.string(),
+  designSystemId: z13.string().nullish(),
+  type: AssetType,
+  originalFileName: z13.string().nullish(),
+  filePath: z13.string(),
+  scope: AssetScope,
+  properties: AssetProperties.nullish(),
+  origin: AssetOrigin.nullish()
+});
+function isImportedAsset(asset) {
+  return !!asset.origin;
+}
+
+// src/dsm/data-sources/data-source.ts
+import { z as z14 } from "zod";
+var DataSourceRemoteType = z14.enum(["Figma", "TokenStudio", "FigmaVariablesPlugin"]);
+var DataSourceUploadRemoteSource = z14.enum(["TokenStudio", "FigmaVariablesPlugin", "Custom"]);
+var DataSourceFigmaState = z14.enum(["Active", "MissingIntegration", "MissingFileAccess", "MissingFileOwner"]);
+var DataSourceAutoImportMode = z14.enum(["Never", "Hourly"]);
+var DataSourceStats = z14.object({
+  tokens: zeroNumberByDefault(),
+  components: zeroNumberByDefault(),
+  assets: zeroNumberByDefault(),
+  frames: zeroNumberByDefault()
+});
+var DataSourceFigmaFileData = z14.object({
+  lastUpdatedAt: z14.coerce.date()
+});
+var DataSourceFigmaFileVersionData = z14.object({
+  id: z14.string(),
+  label: z14.string().optional(),
+  description: z14.string().optional(),
+  createdAt: z14.coerce.date()
+});
+var DataSourceFigmaScope = z14.object({
+  assets: z14.boolean(),
+  components: z14.boolean(),
+  documentationFrames: z14.boolean(),
+  tokens: z14.boolean(),
+  themePersistentId: z14.string().optional()
+});
+var DataSourceFigmaImportMetadata = z14.object({
+  fileData: DataSourceFigmaFileData.optional(),
+  importedPublishedVersion: DataSourceFigmaFileVersionData.optional()
+});
+var DataSourceFigmaRemote = z14.object({
+  type: z14.literal(DataSourceRemoteType.Enum.Figma),
+  fileId: z14.string(),
+  ownerId: z14.string(),
+  ownerName: z14.string(),
+  scope: DataSourceFigmaScope,
+  state: DataSourceFigmaState,
+  lastImportMetadata: DataSourceFigmaImportMetadata.optional(),
+  downloadChunkSize: z14.number().optional()
+});
+var DataSourceTokenStudioRemote = z14.object({
+  type: z14.literal(DataSourceRemoteType.Enum.TokenStudio)
+});
+var DataSourceUploadImportMetadata = z14.record(z14.any());
+var DataSourceUploadRemote = z14.object({
+  type: z14.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
+  remoteId: z14.string(),
+  remoteSourceType: DataSourceUploadRemoteSource,
+  lastImportMetadata: DataSourceUploadImportMetadata.optional()
+});
+var DataSourceRemote = z14.discriminatedUnion("type", [
+  DataSourceFigmaRemote,
+  DataSourceUploadRemote,
+  DataSourceTokenStudioRemote
+]);
+var DataSourceVersion = z14.object({
+  id: z14.string(),
+  createdAt: z14.date(),
+  label: z14.string().nullish(),
+  description: z14.string().nullish()
+});
+function zeroNumberByDefault() {
+  return z14.number().nullish().transform((v) => v ?? 0);
+}
+
+// src/dsm/data-sources/import-job.ts
+import { z as z17 } from "zod";
+
+// src/common/entity.ts
+import { z as z15 } from "zod";
+var Entity = z15.object({
+  id: z15.string(),
+  createdAt: z15.date(),
+  updatedAt: z15.date()
+});
+
+// src/common/object-meta.ts
+import { z as z16 } from "zod";
+var ObjectMeta = z16.object({
+  name: z16.string(),
+  description: z16.string().optional()
+});
+
+// src/dsm/data-sources/import-job.ts
+var ImportJobState = z17.enum(["PendingInput", "Queued", "InProgress", "Failed", "Success"]);
+var ImportJobOperation = z17.enum(["Check", "Import"]);
+var ImportJob = Entity.extend({
+  designSystemId: z17.string(),
+  designSystemVersionId: z17.string(),
+  sourceIds: z17.array(z17.string()),
+  state: ImportJobState,
+  createdByUserId: z17.string().optional(),
+  importContextId: z17.string(),
+  error: z17.string().optional(),
+  sourceType: DataSourceRemoteType
+});
+
+// src/dsm/data-sources/import-summary.ts
+import { z as z79 } from "zod";
+
+// src/dsm/elements/data/base.ts
+import { z as z18 } from "zod";
+var TokenDataAliasSchema = z18.object({
+  aliasTo: z18.string().optional().nullable().transform((v) => v ?? void 0)
+});
+function tokenAliasOrValue(value) {
+  return TokenDataAliasSchema.extend({
+    value: value.optional().nullable().transform((v) => v ?? void 0)
+  });
+}
+
+// src/dsm/elements/data/blur.ts
+import { z as z20 } from "zod";
+
+// src/dsm/elements/data/dimension.ts
+import { z as z19 } from "zod";
+var DimensionUnit = z19.enum(["Pixels", "Percent", "Rem", "Ms", "Raw", "Points"]);
+var DimensionValue = z19.object({
+  unit: DimensionUnit,
+  measure: z19.number()
+});
+var DimensionTokenData = tokenAliasOrValue(DimensionValue);
+
+// src/dsm/elements/data/blur.ts
+var BlurType = z20.enum(["Layer", "Background"]);
+var BlurValue = z20.object({
+  type: BlurType,
+  radius: DimensionTokenData
+});
+var BlurTokenData = tokenAliasOrValue(BlurValue);
+
+// src/dsm/elements/data/border-radius.ts
+import { z as z21 } from "zod";
+var BorderRadiusUnit = z21.enum(["Pixels", "Rem", "Percent"]);
+var BorderRadiusValue = z21.object({
+  unit: BorderRadiusUnit,
+  measure: z21.number()
+});
+var BorderRadiusTokenData = tokenAliasOrValue(BorderRadiusValue);
+
+// src/dsm/elements/data/border-width.ts
+import { z as z22 } from "zod";
+var BorderWidthUnit = z22.enum(["Pixels"]);
+var BorderWidthValue = z22.object({
+  unit: BorderWidthUnit,
+  measure: z22.number()
+});
+var BorderWidthTokenData = tokenAliasOrValue(BorderWidthValue);
+
+// src/dsm/elements/data/border.ts
+import { z as z25 } from "zod";
+
+// src/dsm/elements/data/color.ts
+import { z as z24 } from "zod";
+
+// src/dsm/elements/data/opacity.ts
+import { z as z23 } from "zod";
+var OpacityValue = z23.object({
+  unit: z23.enum(["Raw", "Pixels"]),
+  measure: z23.number()
+});
+var OpacityTokenData = tokenAliasOrValue(OpacityValue);
+
+// src/dsm/elements/data/color.ts
+var ColorValue = z24.object({
+  opacity: OpacityTokenData,
+  color: z24.string().or(TokenDataAliasSchema)
+});
+var ColorTokenData = tokenAliasOrValue(ColorValue);
+
+// src/dsm/elements/data/border.ts
+var BorderPosition = z25.enum(["Inside", "Center", "Outside"]);
+var BorderStyle = z25.enum(["Dashed", "Dotted", "Solid", "Groove"]);
+var BorderValue = z25.object({
+  color: ColorTokenData,
+  width: BorderWidthTokenData,
+  position: BorderPosition,
+  style: BorderStyle.optional()
+});
+var BorderTokenData = tokenAliasOrValue(BorderValue);
+
+// src/dsm/elements/data/component.ts
+import { z as z26 } from "zod";
+var ComponentElementData = z26.object({
+  value: z26.object({
+    thumbnailImage: z26.object({
+      value: z26.object({
+        url: z26.string(),
+        assetId: z26.string()
+      })
+    }),
+    svg: z26.object({
+      value: z26.object({
+        url: z26.string(),
+        assetId: z26.string()
+      })
+    }).optional()
+  })
+});
+
+// src/dsm/elements/data/documentation-block-v1.ts
+import { z as z32 } from "zod";
+
+// src/dsm/elements/raw-element.ts
+import { z as z27 } from "zod";
+var DesignTokenType = z27.enum([
+  "Color",
+  "Border",
+  "Gradient",
+  "Shadow",
+  "Dimension",
+  "Duration",
+  "Size",
+  "Space",
+  "Opacity",
+  "FontSize",
+  "LineHeight",
+  "LetterSpacing",
+  "ParagraphSpacing",
+  "BorderWidth",
+  "BorderRadius",
+  "Duration",
+  "ZIndex",
+  "Image",
+  "String",
+  "ProductCopy",
+  "FontFamily",
+  "FontWeight",
+  "TextDecoration",
+  "TextCase",
+  "Visibility",
+  "Typography",
+  "Blur",
+  "Font"
+]);
+var tokenElementTypes = [...DesignTokenType.options.filter((v) => v !== "Font")];
+var DesignElementType = DesignTokenType.or(
+  z27.enum([
+    "Component",
+    "Theme",
+    "Documentation",
+    "DocumentationPage",
+    "DesignSystemComponent",
+    "ElementGroup",
+    "FigmaNodeStructure",
+    "FigmaNodeReference",
+    "PageBlock"
+  ])
+);
+function isTokenType(type) {
+  return DesignTokenType.safeParse(type).success;
+}
+var DesignElementCategory = z27.enum([
+  "Token",
+  "Component",
+  "DesignSystemComponent",
+  "DocumentationPage",
+  "Theme",
+  "PageBlock"
+]);
+var DesignSystemElementExportProps = z27.object({
+  isAsset: z27.boolean().nullish().transform((v) => v ?? false),
+  codeName: z27.string().nullish()
+});
+var ShallowDesignElement = z27.object({
+  id: z27.string(),
+  persistentId: z27.string(),
+  designSystemVersionId: z27.string(),
+  type: DesignElementType,
+  brandPersistentId: z27.string().optional(),
+  parentPersistentId: z27.string().optional(),
+  shortPersistentId: z27.string().optional(),
+  sortOrder: z27.number()
+});
+var DesignElement = ShallowDesignElement.extend({
+  meta: ObjectMeta,
+  childType: DesignElementType.optional(),
+  slug: z27.string().optional(),
+  userSlug: z27.string().optional(),
+  createdAt: z27.date(),
+  updatedAt: z27.date(),
+  exportProperties: DesignSystemElementExportProps.optional(),
+  data: z27.any(),
+  // TODO this should be an object, not any.
+  origin: z27.any().optional()
+  // TODO object, not any.
+});
+
+// src/dsm/properties/property-definition.ts
+import { z as z28 } from "zod";
+var ElementPropertyType = z28.enum(["Text", "Number", "Boolean", "Select", "Generic", "Link", "URL"]);
+var ElementPropertyTargetType = z28.enum(["Token", "Component", "DocumentationPage"]);
+var ElementPropertyLinkType = z28.enum(["FigmaComponent", "DocumentationPage"]);
+var ColorTokenInlineData = z28.object({
+  value: z28.string()
+});
+var ElementPropertyDefinitionOption = z28.object({
+  id: z28.string(),
+  name: z28.string(),
+  backgroundColor: ColorTokenInlineData.optional()
+});
+var ElementPropertyDefinition = z28.object({
+  id: z28.string(),
+  designSystemVersionId: z28.string(),
+  persistentId: z28.string(),
+  name: z28.string(),
+  codeName: z28.string(),
+  description: z28.string(),
+  type: ElementPropertyType,
+  targetElementType: ElementPropertyTargetType,
+  options: z28.array(ElementPropertyDefinitionOption).nullish(),
+  linkElementType: ElementPropertyLinkType.nullish()
+});
+
+// src/dsm/properties/property-value.ts
+import { z as z29 } from "zod";
+var ElementPropertyValue = z29.object({
+  id: z29.string(),
+  designSystemVersionId: z29.string(),
+  targetElementPersistentId: z29.string(),
+  definitionPersistentId: z29.string(),
+  stringValue: z29.string().nullish(),
+  numberValue: z29.number().nullish(),
+  booleanValue: z29.boolean().nullish(),
+  referenceValue: z29.string().nullish(),
+  referenceValuePreview: z29.string().nullish()
+});
+
+// src/dsm/elements/primitives/point.ts
+import { z as z30 } from "zod";
+var Point2D = z30.object({
+  x: z30.number(),
+  y: z30.number()
+});
+
+// src/dsm/elements/primitives/size.ts
+import { z as z31 } from "zod";
+var nullSize = { height: -1, width: -1 };
+function isNullSize(size) {
+  return size.height === nullSize.height && size.width === nullSize.width;
+}
+var Size = z31.object({
+  width: z31.number().nullish().transform((v) => v ?? nullSize.width),
+  height: z31.number().nullish().transform((v) => v ?? nullSize.height)
+});
+var SizeOrUndefined = Size.optional().transform((v) => {
+  if (!v)
+    return void 0;
+  if (isNullSize(v))
+    return void 0;
+  return v;
+});
+
+// src/helpers/db.ts
+function zodCreateInputOmit() {
+  return {
+    id: true,
+    createdAt: true,
+    updatedAt: true
+  };
+}
+function zodUpdateInputOmit() {
+  return {
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+    persistentId: true
+  };
+}
+
+// src/helpers/nullish-to-optional.ts
+function nullishToOptional(type) {
+  return type.nullish().transform((t) => t ?? void 0);
+}
+
+// src/dsm/elements/data/documentation-block-v1.ts
+var PageBlockCalloutType = z32.enum(["Info", "Success", "Warning", "Error"]);
+var PageBlockTypeV1 = z32.enum([
+  "Text",
+  "Heading",
+  "Code",
+  "UnorderedList",
+  "OrderedList",
+  "Quote",
+  "Callout",
+  "Divider",
+  "Image",
+  "Embed",
+  "Link",
+  "Shortcuts",
+  "FigmaEmbed",
+  "YoutubeEmbed",
+  "StorybookEmbed",
+  "Token",
+  "TokenGroup",
+  "TokenList",
+  "Component",
+  "ComponentGroup",
+  "Theme",
+  "ComponentSandbox",
+  "Custom",
+  "FigmaFrames",
+  "ComponentAssets",
+  "RenderCode",
+  "Tabs",
+  "TabItem",
+  "Table",
+  "TableRow",
+  "TableCell"
+]);
+var PageBlockCodeLanguage = z32.enum([
+  "Angular",
+  "Bash",
+  "C",
+  "Cpp",
+  "Csharp",
+  "CSS",
+  "Dart",
+  "Handlebars",
+  "HTML",
+  "Java",
+  "Javascript",
+  "JSON",
+  "ReactJSX",
+  "ReactTSX",
+  "Kotlin",
+  "Lua",
+  "Markdown",
+  "ObjectiveC",
+  "PHP",
+  "Plain",
+  "Python",
+  "Ruby",
+  "Rust",
+  "Sass",
+  "SCSS",
+  "Svetle",
+  "Swift",
+  "Twig",
+  "Typescript",
+  "Vue",
+  "XML",
+  "YAML"
+]);
+var PageBlockAlignment = z32.enum(["Left", "Center", "Stretch", "Right"]);
+var PageBlockThemeType = z32.enum(["Override", "Comparison"]);
+var PageBlockAssetType = z32.enum(["image", "figmaFrame"]);
+var PageBlockTilesAlignment = z32.enum(["Center", "FrameHeight"]);
+var PageBlockTilesLayout = z32.enum(["C8", "C7", "C6", "C5", "C4", "C3", "C2", "C1", "C1_75"]);
+var PageBlockTheme = z32.object({
+  themeIds: z32.array(z32.string()),
+  type: PageBlockThemeType
+});
+var PageBlockUrlPreview = z32.object({
+  title: nullishToOptional(z32.string()),
+  description: nullishToOptional(z32.string()),
+  thumbnailUrl: nullishToOptional(z32.string())
+});
+var PageBlockFrameOrigin = z32.object({
+  sourceFileName: nullishToOptional(z32.string()),
+  title: nullishToOptional(z32.string()),
+  previewUrl: nullishToOptional(z32.string()),
+  valid: nullishToOptional(z32.boolean()),
+  referenceId: nullishToOptional(z32.string()),
+  assetId: nullishToOptional(z32.string()),
+  assetScale: nullishToOptional(z32.number()),
+  width: nullishToOptional(z32.number()),
+  height: nullishToOptional(z32.number())
+});
+var PageBlockFrame = z32.object({
+  persistentId: z32.string(),
+  sourceId: z32.string(),
+  sourceFrameId: z32.string(),
+  title: nullishToOptional(z32.string()),
+  description: nullishToOptional(z32.string()),
+  backgroundColor: nullishToOptional(ColorTokenInlineData),
+  origin: nullishToOptional(PageBlockFrameOrigin)
+});
+var PageBlockAsset = z32.object({
+  type: PageBlockAssetType,
+  id: nullishToOptional(z32.string()),
+  url: nullishToOptional(z32.string()),
+  figmaFrame: nullishToOptional(PageBlockFrame)
+});
+var PageBlockLinkPreview = z32.object({
+  title: nullishToOptional(z32.string()),
+  valid: nullishToOptional(z32.boolean())
+});
+var PageBlockShortcut = z32.object({
+  persistentId: z32.string(),
+  title: nullishToOptional(z32.string()),
+  description: nullishToOptional(z32.string()),
+  asset: nullishToOptional(PageBlockAsset),
+  documentationItemId: nullishToOptional(z32.string()),
+  url: nullishToOptional(z32.string()),
+  urlPreview: nullishToOptional(PageBlockUrlPreview),
+  documentationItemPreview: nullishToOptional(PageBlockLinkPreview)
+});
+var PageBlockCustomBlockPropertyImageValue = z32.object({
+  asset: nullishToOptional(PageBlockAsset),
+  assetId: nullishToOptional(z32.string()),
+  assetUrl: nullishToOptional(z32.string())
+});
+var PageBlockCustomBlockPropertyValue = z32.object({
+  key: z32.string(),
+  value: z32.any()
+  // TODO Artem: for some reason there are cases when there's an array here in the DB
+  // e.g. element id 67451 in the dev db
+  // value: z
+  //   .boolean()
+  //   .or(z.number())
+  //   .or(z.string())
+  //   .or(ColorTokenData)
+  //   .or(TypographyTokenData)
+  //   .or(PageBlockCustomBlockPropertyImageValue),
+});
+var PageBlockFigmaFrameProperties = z32.object({
+  alignment: PageBlockTilesAlignment,
+  layout: PageBlockTilesLayout,
+  backgroundColor: nullishToOptional(ColorTokenInlineData),
+  showTitles: z32.boolean()
+});
+var PageBlockRenderCodeProperties = z32.object({
+  showCode: z32.boolean()
+});
+var PageBlockAssetComponent = z32.object({
+  persistentId: z32.string(),
+  componentAssetId: z32.string(),
+  title: nullishToOptional(z32.string()),
+  description: nullishToOptional(z32.string()),
+  backgroundColor: nullishToOptional(ColorTokenInlineData)
+});
+var PageBlockTableColumn = z32.object({
+  id: z32.string(),
+  width: DimensionTokenData
+});
+var PageBlockTableProperties = z32.object({
+  showBorders: z32.boolean(),
+  showHeaderRow: z32.boolean(),
+  showHeaderColumn: z32.boolean(),
+  columns: z32.array(PageBlockTableColumn)
+});
+var PageBlockTextSpanAttributeType = z32.enum(["Bold", "Italic", "Link", "Strikethrough", "Code"]);
+var PageBlockTextSpanAttribute = z32.object({
+  type: PageBlockTextSpanAttributeType,
+  link: nullishToOptional(z32.string()),
+  documentationItemId: nullishToOptional(z32.string()),
+  openInNewWindow: nullishToOptional(z32.boolean())
+});
+var PageBlockTextSpan = z32.object({
+  text: z32.string(),
+  attributes: z32.array(PageBlockTextSpanAttribute)
+});
+var PageBlockText = z32.object({
+  spans: z32.array(PageBlockTextSpan)
+});
+var PageBlockBaseV1 = z32.object({
+  persistentId: z32.string(),
+  type: PageBlockTypeV1,
+  // Element linking
+  designObjectId: nullishToOptional(z32.string()),
+  designObjectIds: nullishToOptional(z32.array(z32.string())),
+  tokenType: nullishToOptional(DesignTokenType.or(z32.literal("Font"))),
+  showNestedGroups: nullishToOptional(z32.boolean()),
+  brandId: nullishToOptional(z32.string()),
+  // Rich text
+  text: nullishToOptional(PageBlockText),
+  caption: nullishToOptional(z32.string()),
+  headingType: nullishToOptional(z32.number().min(1).max(3)),
+  codeLanguage: nullishToOptional(PageBlockCodeLanguage),
+  calloutType: nullishToOptional(PageBlockCalloutType),
+  urlInput: nullishToOptional(z32.string()),
+  url: nullishToOptional(z32.string()),
+  urlPreview: nullishToOptional(PageBlockUrlPreview),
+  // Image
+  asset: nullishToOptional(PageBlockAsset),
+  alignment: nullishToOptional(PageBlockAlignment),
+  // Shortcuts block
+  shortcuts: nullishToOptional(z32.array(PageBlockShortcut)),
+  // Custom blocks
+  customBlockKey: nullishToOptional(z32.string()),
+  customBlockProperties: nullishToOptional(z32.array(PageBlockCustomBlockPropertyValue)),
+  variantKey: nullishToOptional(z32.string()),
+  // Figma frames
+  figmaFrameProperties: nullishToOptional(PageBlockFigmaFrameProperties),
+  figmaFrames: nullishToOptional(z32.array(PageBlockFrame)),
+  // Generic
+  size: nullishToOptional(Size),
+  backgroundColor: nullishToOptional(ColorTokenInlineData),
+  // Render code
+  renderCodeProperties: nullishToOptional(PageBlockRenderCodeProperties),
+  // Component assets
+  componentAssets: nullishToOptional(z32.array(PageBlockAssetComponent)),
+  // Tables
+  tableProperties: nullishToOptional(PageBlockTableProperties),
+  columnId: nullishToOptional(z32.string()),
+  // Token spreadsheet
+  theme: nullishToOptional(PageBlockTheme),
+  blacklistedElementProperties: nullishToOptional(z32.array(z32.string())),
+  // Arbitrary
+  userMetadata: nullishToOptional(z32.string())
+});
+var PageBlockV1 = PageBlockBaseV1.extend({
+  children: z32.lazy(
+    () => PageBlockV1.array().nullish().transform((t) => t ?? [])
+  )
+});
+function traversePageBlocksV1(blocks, action) {
+  for (const block of blocks) {
+    action(block);
+    traversePageBlocksV1(block.children, action);
+  }
+}
+
+// src/dsm/elements/data/documentation-block-v2.ts
+import { z as z33 } from "zod";
+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
+});
+var PageBlockItemUntypedPropertyValue = z33.object({
+  value: z33.any()
+}).and(z33.record(z33.any()));
+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()
+});
+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,
+  documentationItemId: z33.string().optional(),
+  pageHeadingId: z33.string().optional(),
+  url: z33.string().optional(),
+  openInNewTab: z33.boolean().optional()
+});
+var PageBlockItemV2 = z33.object({
+  id: z33.string(),
+  linksTo: PageBlockLinkV2.optional(),
+  props: z33.record(PageBlockItemUntypedPropertyValue)
+});
+var PageBlockDataV2 = z33.object({
+  packageId: z33.string(),
+  variantId: z33.string().optional(),
+  indentLevel: z33.number(),
+  appearance: PageBlockAppearanceV2.optional(),
+  items: z33.array(PageBlockItemV2)
+});
+
+// src/dsm/elements/data/documentation-page-v1.ts
+import { z as z35 } from "zod";
+
+// src/dsm/elements/data/documentation.ts
+import { z as z34 } from "zod";
+var DocumentationItemConfiguration = z34.object({
+  showSidebar: z34.boolean(),
+  header: z34.any()
+});
+
+// src/dsm/elements/data/documentation-page-v1.ts
+var DocumentationPageDataV1 = z35.object({
+  blocks: z35.array(PageBlockV1),
+  configuration: nullishToOptional(DocumentationItemConfiguration)
+});
+var DocumentationPageElementDataV1 = z35.object({
+  value: DocumentationPageDataV1
+});
+
+// src/dsm/elements/data/documentation-page-v2.ts
+import { z as z36 } from "zod";
+var DocumentationPageDataV2 = z36.object({
+  configuration: nullishToOptional(DocumentationItemConfiguration)
+});
+var DocumentationPageElementDataV2 = z36.object({
+  value: DocumentationPageDataV2
+});
+
+// src/dsm/elements/data/duration.ts
+import { z as z37 } from "zod";
+var DurationUnit = z37.enum(["Ms"]);
+var DurationValue = z37.object({
+  unit: DurationUnit,
+  measure: z37.number()
+});
+var DurationTokenData = tokenAliasOrValue(DurationValue);
+
+// src/dsm/elements/data/figma-file-structure.ts
+import { z as z38 } from "zod";
+var FigmaFileStructureNodeType = z38.enum(["DOCUMENT", "CANVAS", "FRAME", "COMPONENT", "COMPONENT_SET"]);
+var FigmaFileStructureNodeBase = z38.object({
+  id: z38.string(),
+  name: z38.string(),
+  type: FigmaFileStructureNodeType,
+  size: SizeOrUndefined,
+  parentComponentSetId: z38.string().optional()
+});
+var FigmaFileStructureNode = FigmaFileStructureNodeBase.extend({
+  children: z38.lazy(() => FigmaFileStructureNode.array())
+});
+var FigmaFileStructureStatistics = z38.object({
+  frames: z38.number().nullable().optional().transform((v) => v ?? 0),
+  components: z38.number().nullable().optional().transform((v) => v ?? 0),
+  componentSets: z38.number().nullable().optional().transform((v) => v ?? 0)
+});
+var FigmaFileStructureElementData = z38.object({
+  value: z38.object({
+    structure: FigmaFileStructureNode,
+    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);
+}
+
+// src/dsm/elements/data/figma-node-reference.ts
+import { z as z39 } from "zod";
+var FigmaNodeReferenceData = z39.object({
+  structureElementId: z39.string(),
+  nodeId: z39.string(),
+  fileId: z39.string().optional(),
+  valid: z39.boolean(),
+  assetId: z39.string().optional(),
+  assetScale: z39.number().optional(),
+  assetWidth: z39.number().optional(),
+  assetHeight: z39.number().optional(),
+  assetUrl: z39.string().optional()
+});
+var FigmaNodeReferenceElementData = z39.object({
+  value: FigmaNodeReferenceData
+});
+
+// src/dsm/elements/data/font-family.ts
+import { z as z40 } from "zod";
+var FontFamilyValue = z40.string();
+var FontFamilyTokenData = tokenAliasOrValue(FontFamilyValue);
+
+// src/dsm/elements/data/font-size.ts
+import { z as z41 } from "zod";
+var FontSizeUnit = z41.enum(["Pixels", "Rem", "Percent"]);
+var FontSizeValue = z41.object({
+  unit: FontSizeUnit,
+  measure: z41.number()
+});
+var FontSizeTokenData = tokenAliasOrValue(FontSizeValue);
+
+// src/dsm/elements/data/font-weight.ts
+import { z as z42 } from "zod";
+var FontWeightValue = z42.string();
+var FontWeightTokenData = tokenAliasOrValue(FontWeightValue);
+
+// src/dsm/elements/data/gradient.ts
+import { z as z43 } from "zod";
+var GradientType = z43.enum(["Linear", "Radial", "Angular"]);
+var GradientStop = z43.object({
+  position: z43.number(),
+  color: ColorTokenData
+});
+var GradientLayerValue = z43.object({
+  from: Point2D,
+  to: Point2D,
+  type: GradientType,
+  aspectRatio: nullishToOptional(z43.number()),
+  // z.number(),
+  stops: z43.array(GradientStop).min(2)
+});
+var GradientLayerData = tokenAliasOrValue(GradientLayerValue);
+var GradientTokenValue = z43.array(GradientLayerData);
+var GradientTokenData = tokenAliasOrValue(GradientTokenValue);
+
+// src/dsm/elements/data/group.ts
+import { z as z44 } from "zod";
+var DocumentationGroupBehavior = z44.enum(["Group", "Tabs"]);
+var ElementGroupData = z44.object({
+  behavior: nullishToOptional(DocumentationGroupBehavior.optional()),
+  configuration: nullishToOptional(DocumentationItemConfiguration)
+});
+var ElementGroupElementData = z44.object({
+  value: ElementGroupData.optional()
+});
+
+// src/dsm/elements/data/letter-spacing.ts
+import { z as z45 } from "zod";
+var LetterSpacingUnit = z45.enum(["Pixels", "Rem", "Percent"]);
+var LetterSpacingValue = z45.object({
+  unit: LetterSpacingUnit,
+  measure: z45.number()
+});
+var LetterSpacingTokenData = tokenAliasOrValue(LetterSpacingValue);
+
+// src/dsm/elements/data/line-height.ts
+import { z as z46 } from "zod";
+var LineHeightUnit = z46.enum(["Pixels", "Rem", "Percent", "Raw"]);
+var LineHeightValue = z46.object({
+  unit: LineHeightUnit,
+  measure: z46.number()
+});
+var LineHeightTokenData = tokenAliasOrValue(LineHeightValue);
+
+// src/dsm/elements/data/paragraph-indent.ts
+import { z as z47 } from "zod";
+var ParagraphIndentUnit = z47.enum(["Pixels", "Rem", "Percent"]);
+var ParagraphIndentValue = z47.object({
+  unit: ParagraphIndentUnit,
+  measure: z47.number()
+});
+var ParagraphIndentTokenData = tokenAliasOrValue(ParagraphIndentValue);
+
+// src/dsm/elements/data/paragraph-spacing.ts
+import { z as z48 } from "zod";
+var ParagraphSpacingUnit = z48.enum(["Pixels", "Rem", "Percent"]);
+var ParagraphSpacingValue = z48.object({
+  unit: ParagraphSpacingUnit,
+  measure: z48.number()
+});
+var ParagraphSpacingTokenData = tokenAliasOrValue(ParagraphSpacingValue);
+
+// src/dsm/elements/data/product-copy.ts
+import { z as z49 } from "zod";
+var ProductCopyValue = z49.string();
+var ProductCopyTokenData = tokenAliasOrValue(ProductCopyValue);
+
+// src/dsm/elements/data/shadow.ts
+import { z as z50 } from "zod";
+var ShadowType = z50.enum(["Drop", "Inner"]);
+var ShadowLayerValue = z50.object({
+  color: ColorTokenData,
+  x: z50.number(),
+  y: z50.number(),
+  radius: z50.number(),
+  spread: z50.number(),
+  opacity: OpacityTokenData,
+  type: ShadowType
+});
+var ShadowTokenDataBase = tokenAliasOrValue(ShadowLayerValue);
+var ShadowTokenData = tokenAliasOrValue(z50.array(ShadowTokenDataBase));
+
+// src/dsm/elements/data/size.ts
+import { z as z51 } from "zod";
+var SizeUnit = z51.enum(["Pixels", "Rem", "Percent"]);
+var SizeValue = z51.object({
+  unit: SizeUnit,
+  measure: z51.number()
+});
+var SizeTokenData = tokenAliasOrValue(SizeValue);
+
+// src/dsm/elements/data/space.ts
+import { z as z52 } from "zod";
+var SpaceUnit = z52.enum(["Pixels", "Rem", "Percent"]);
+var SpaceValue = z52.object({
+  unit: SpaceUnit,
+  measure: z52.number()
+});
+var SpaceTokenData = tokenAliasOrValue(SpaceValue);
+
+// src/dsm/elements/data/string.ts
+import { z as z53 } from "zod";
+var StringValue = z53.string();
+var StringTokenData = tokenAliasOrValue(StringValue);
+
+// src/dsm/elements/data/text-case.ts
+import { z as z54 } from "zod";
+var TextCase = z54.enum(["Original", "Upper", "Lower", "Camel", "SmallCaps"]);
+var TextCaseValue = TextCase;
+var TextCaseTokenData = tokenAliasOrValue(TextCaseValue);
+
+// src/dsm/elements/data/text-decoration.ts
+import { z as z55 } from "zod";
+var TextDecoration = z55.enum(["None", "Underline", "Strikethrough"]);
+var TextDecorationValue = TextDecoration;
+var TextDecorationTokenData = tokenAliasOrValue(TextDecorationValue);
+
+// src/dsm/elements/data/typography.ts
+import { z as z56 } from "zod";
+var TypographyValue = z56.object({
+  fontSize: FontSizeTokenData,
+  fontFamily: FontFamilyTokenData,
+  fontWeight: FontWeightTokenData,
+  textDecoration: TextDecorationTokenData,
+  textCase: TextCaseTokenData,
+  letterSpacing: LetterSpacingTokenData.optional(),
+  lineHeight: LineHeightTokenData.optional(),
+  paragraphIndent: ParagraphIndentTokenData.optional(),
+  paragraphSpacing: ParagraphSpacingTokenData.optional()
+});
+var TypographyTokenData = tokenAliasOrValue(TypographyValue);
+
+// src/dsm/elements/data/visibility.ts
+import { z as z57 } from "zod";
+var Visibility = z57.enum(["Hidden", "Visible"]);
+var VisibilityValue = Visibility;
+var VisibilityTokenData = tokenAliasOrValue(VisibilityValue);
+
+// src/dsm/elements/data/z-index.ts
+import { z as z58 } from "zod";
+var ZIndexUnit = z58.enum(["Raw"]);
+var ZIndexValue = z58.object({
+  unit: ZIndexUnit,
+  measure: z58.number()
+});
+var ZIndexTokenData = tokenAliasOrValue(ZIndexValue);
+
+// src/dsm/elements/base.ts
+import { z as z59 } from "zod";
+var DesignElementOrigin = z59.object({
+  id: z59.string(),
+  sourceId: z59.string(),
+  name: z59.string()
+});
+var DesignElementBase = z59.object({
+  id: z59.string(),
+  persistentId: z59.string(),
+  meta: ObjectMeta,
+  designSystemVersionId: z59.string(),
+  createdAt: z59.date(),
+  updatedAt: z59.date()
+});
+var DesignElementImportedBase = DesignElementBase.extend({
+  origin: DesignElementOrigin
+});
+var DesignElementGroupablePart = z59.object({
+  parentPersistentId: z59.string().optional(),
+  sortOrder: z59.number()
+});
+var DesignElementGroupableBase = DesignElementBase.extend(DesignElementGroupablePart.shape);
+var DesignElementGroupableRequiredPart = DesignElementGroupablePart.extend({
+  parentPersistentId: z59.string()
+});
+var DesignElementBrandedPart = z59.object({
+  brandPersistentId: z59.string()
+});
+var DesignElementSlugPart = z59.object({
+  slug: z59.string().optional(),
+  userSlug: z59.string().optional()
+});
+
+// src/dsm/elements/component.ts
+import { z as z60 } from "zod";
+var ComponentOriginPart = z60.object({
+  nodeId: z60.string().optional(),
+  width: z60.number().optional(),
+  height: z60.number().optional()
+});
+var ComponentAsset = z60.object({
+  assetId: z60.string(),
+  assetPath: z60.string()
+});
+var ComponentOrigin = DesignElementOrigin.extend(ComponentOriginPart.shape);
+var Component = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape).extend(DesignElementBrandedPart.shape).extend({
+  origin: ComponentOrigin.optional(),
+  thumbnail: ComponentAsset,
+  svg: ComponentAsset.optional(),
+  isAsset: z60.boolean()
+});
+function isImportedComponent(component) {
+  return !!component.origin;
+}
+
+// src/dsm/elements/documentation-page-v1.ts
+import { z as z61 } from "zod";
+var DocumentationPageV1 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape).extend(DesignElementSlugPart.shape).extend({
+  shortPersistentId: z61.string(),
+  data: DocumentationPageDataV1
+});
+var DocumentationPageDTOV1 = DocumentationPageV1.omit({
+  data: true,
+  meta: true,
+  parentPersistentId: true,
+  sortOrder: true
+}).extend(DocumentationPageV1.shape.data.shape).extend({
+  title: z61.string(),
+  path: z61.string()
+});
+
+// src/dsm/elements/documentation-page-v2.ts
+import { z as z62 } from "zod";
+var DocumentationPageV2 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape).extend(DesignElementSlugPart.shape).extend({
+  shortPersistentId: z62.string(),
+  data: DocumentationPageDataV2
+});
+
+// src/dsm/elements/figma-file-structures.ts
+import { z as z63 } from "zod";
+var FigmaFileStructureOrigin = z63.object({
+  sourceId: z63.string(),
+  fileId: z63.string().optional()
+});
+var FigmaFileStructureData = z63.object({
+  rootNode: FigmaFileStructureNode,
+  assetsInFile: FigmaFileStructureStatistics
+});
+var FigmaFileStructure = DesignElementBase.extend({
+  origin: FigmaFileStructureOrigin,
+  data: FigmaFileStructureData
+});
+function traverseStructure(node, action) {
+  action(node);
+  for (const child of node.children) {
+    traverseStructure(child, action);
+  }
+}
+
+// src/dsm/elements/figma-node-reference.ts
+var FigmaNodeReference = DesignElementBase.extend({
+  data: FigmaNodeReferenceData
+});
+
+// src/dsm/elements/group.ts
+import { z as z64 } from "zod";
+var ElementGroup = DesignElementBase.extend(DesignElementGroupablePart.shape).extend(DesignElementSlugPart.shape).extend(DesignElementBrandedPart.partial().shape).extend({
+  shortPersistentId: z64.string().optional(),
+  childType: DesignElementType,
+  data: ElementGroupData.optional()
+});
+var BrandedElementGroup = ElementGroup.extend(DesignElementBrandedPart.shape);
+var DocumentationGroupDTO = ElementGroup.omit({
+  sortOrder: true,
+  parentPersistentId: true,
+  brandPersistentId: true,
+  meta: true,
+  childType: true,
+  data: true,
+  shortPersistentId: true
+}).extend({
+  title: z64.string(),
+  isRoot: z64.boolean(),
+  childrenIds: z64.array(z64.string()),
+  groupBehavior: DocumentationGroupBehavior,
+  configuration: DocumentationItemConfiguration,
+  shortPersistentId: z64.string()
+});
+
+// src/dsm/elements/page-block-v2.ts
+import { z as z65 } from "zod";
+var PageBlockV2 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape).extend({
+  data: PageBlockDataV2
+});
+var PageBlockEditorModelV2 = z65.object({
+  id: z65.string(),
+  data: PageBlockDataV2
+});
+
+// src/dsm/elements/theme.ts
+import { z as z67 } from "zod";
+
+// src/dsm/elements/tokens.ts
+import { z as z66 } from "zod";
+var DesignTokenOriginPart = z66.object({
+  referenceOriginId: z66.string().optional(),
+  referencePersistentId: z66.string().optional()
+});
+var DesignTokenOrigin = DesignElementOrigin.extend(DesignTokenOriginPart.shape);
+var DesignTokenBase = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape).extend(DesignElementBrandedPart.shape).extend({
+  origin: DesignTokenOrigin.optional()
+});
+var CreateDesignTokenBase = DesignTokenBase.omit(zodCreateInputOmit());
+var UpdateDesignTokenBase = DesignTokenBase.omit({
+  ...zodUpdateInputOmit(),
+  brandPersistentId: true,
+  designSystemVersionId: true
+});
+var BlurTokenTypedData = z66.object({
+  type: z66.literal("Blur"),
+  data: BlurTokenData
+});
+var ColorTokenTypedData = z66.object({
+  type: z66.literal("Color"),
+  data: ColorTokenData
+});
+var GradientTokenTypedData = z66.object({
+  type: z66.literal("Gradient"),
+  data: GradientTokenData
+});
+var OpacityTokenTypedData = z66.object({
+  type: z66.literal("Opacity"),
+  data: OpacityTokenData
+});
+var ShadowTokenTypedData = z66.object({
+  type: z66.literal("Shadow"),
+  data: ShadowTokenData
+});
+var TypographyTokenTypedData = z66.object({
+  type: z66.literal("Typography"),
+  data: TypographyTokenData
+});
+var StringTokenTypedData = z66.object({
+  type: z66.literal("String"),
+  data: StringTokenData
+});
+var DimensionTokenTypedData = z66.object({
+  type: z66.literal("Dimension"),
+  data: DimensionTokenData
+});
+var FontSizeTokenTypedData = z66.object({
+  type: z66.literal("FontSize"),
+  data: FontSizeTokenData
+});
+var FontFamilyTokenTypedData = z66.object({
+  type: z66.literal("FontFamily"),
+  data: FontFamilyTokenData
+});
+var FontWeightTokenTypedData = z66.object({
+  type: z66.literal("FontWeight"),
+  data: FontWeightTokenData
+});
+var LetterSpacingTokenTypedData = z66.object({
+  type: z66.literal("LetterSpacing"),
+  data: LetterSpacingTokenData
+});
+var LineHeightTokenTypedData = z66.object({
+  type: z66.literal("LineHeight"),
+  data: LineHeightTokenData
+});
+var ParagraphSpacingTokenTypedData = z66.object({
+  type: z66.literal("ParagraphSpacing"),
+  data: ParagraphSpacingTokenData
+});
+var TextCaseTokenTypedData = z66.object({
+  type: z66.literal("TextCase"),
+  data: TextCaseTokenData
+});
+var TextDecorationTokenTypedData = z66.object({
+  type: z66.literal("TextDecoration"),
+  data: TextDecorationTokenData
+});
+var BorderRadiusTokenTypedData = z66.object({
+  type: z66.literal("BorderRadius"),
+  data: BorderRadiusTokenData
+});
+var BorderWidthTokenTypedData = z66.object({
+  type: z66.literal("BorderWidth"),
+  data: BorderWidthTokenData
+});
+var BorderTypedData = z66.object({
+  type: z66.literal("Border"),
+  data: BorderTokenData
+});
+var ProductCopyTypedData = z66.object({
+  type: z66.literal("ProductCopy"),
+  data: ProductCopyTokenData
+});
+var SizeTypedData = z66.object({
+  type: z66.literal("Size"),
+  data: SizeTokenData
+});
+var SpaceTypedData = z66.object({
+  type: z66.literal("Space"),
+  data: SpaceTokenData
+});
+var VisibilityTypedData = z66.object({
+  type: z66.literal("Visibility"),
+  data: VisibilityTokenData
+});
+var ZIndexTypedData = z66.object({
+  type: z66.literal("ZIndex"),
+  data: ZIndexTokenData
+});
+var DurationTypedData = z66.object({
+  type: z66.literal("Duration"),
+  data: DurationTokenData
+});
+var FontTypedData = z66.object({
+  type: z66.literal("Font"),
+  data: z66.record(z66.any())
+});
+var DesignTokenTypedData = z66.discriminatedUnion("type", [
+  BlurTokenTypedData,
+  BorderRadiusTokenTypedData,
+  BorderWidthTokenTypedData,
+  BorderTypedData,
+  ColorTokenTypedData,
+  DimensionTokenTypedData,
+  DurationTypedData,
+  FontSizeTokenTypedData,
+  FontFamilyTokenTypedData,
+  FontWeightTokenTypedData,
+  GradientTokenTypedData,
+  LetterSpacingTokenTypedData,
+  LineHeightTokenTypedData,
+  OpacityTokenTypedData,
+  ParagraphSpacingTokenTypedData,
+  ProductCopyTypedData,
+  ShadowTokenTypedData,
+  SizeTypedData,
+  SpaceTypedData,
+  StringTokenTypedData,
+  TextCaseTokenTypedData,
+  TextDecorationTokenTypedData,
+  TypographyTokenTypedData,
+  VisibilityTypedData,
+  ZIndexTypedData,
+  FontTypedData
+]);
+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);
+}
+
+// src/dsm/elements/theme.ts
+var ThemeOverrideOriginPart = DesignTokenOriginPart;
+var ThemeOverrideOrigin = DesignTokenOrigin;
+var ThemeOverride = DesignTokenTypedData.and(
+  z67.object({
+    tokenPersistentId: z67.string(),
+    origin: ThemeOverrideOrigin.optional().nullable().transform((v) => v ?? void 0)
+  })
+);
+var ThemeElementData = z67.object({
+  value: z67.object({
+    overrides: z67.array(ThemeOverride)
+  })
+});
+var ThemeOriginPart = z67.object({});
+var ThemeOriginObject = z67.object({
+  id: z67.string(),
+  name: z67.string()
+});
+var ThemeOriginSource = z67.object({
+  sourceId: z67.string(),
+  sourceObjects: z67.array(ThemeOriginObject)
+});
+var ThemeOrigin = z67.object({
+  sources: z67.array(ThemeOriginSource)
+});
+var Theme = DesignElementBase.extend(DesignElementBrandedPart.shape).extend({
+  origin: ThemeOrigin.optional(),
+  overrides: z67.array(ThemeOverride)
+});
+
+// src/dsm/import/support/figma-files.ts
+import { z as z68 } from "zod";
+var FigmaFileDownloadScope = z68.object({
+  styles: z68.boolean(),
+  components: z68.boolean(),
+  currentVersion: z68.literal("__latest__").nullable(),
+  publishedVersion: z68.string().nullable(),
+  downloadChunkSize: z68.number().optional()
+});
+var FigmaFileAccessData = z68.object({
+  accessToken: z68.string()
+});
+
+// src/dsm/import/support/import-context.ts
+import { z as z69 } from "zod";
+var ImportFunctionInput = z69.object({
+  importJobId: z69.string(),
+  importContextId: z69.string(),
+  designSystemId: z69.string().optional()
+});
+var ImportedFigmaSourceData = z69.object({
+  sourceId: z69.string(),
+  figmaRemote: DataSourceFigmaRemote
+});
+var FigmaImportBaseContext = z69.object({
+  designSystemId: z69.string(),
+  /**
+   * Data required for accessing Figma files. This should contain access data for all file ids
+   * mentioned in the `importedSourceDataBySourceId`
+   *
+   * fileId: file data
+   */
+  fileAccessByFileId: z69.record(FigmaFileAccessData),
+  /**
+   * Figma source data for which import was requested
+   *
+   * sourceId: source data
+   */
+  importedSourceDataBySourceId: z69.record(ImportedFigmaSourceData)
+});
+var ChangedImportedFigmaSourceData = ImportedFigmaSourceData.extend({
+  importMetadata: DataSourceFigmaImportMetadata
+});
+var FigmaImportContextWithDownloadScopes = FigmaImportBaseContext.extend({
+  /**
+   * Describes what to download from each file, this should contain all file id mentioned in
+   * importMetadataBySourceId.
+   *
+   * File id -> file download scope
+   */
+  fileDownloadScopesByFileId: z69.record(FigmaFileDownloadScope),
+  /**
+   * Sources filtered down to the ones that have changed since last import and therefore need to be
+   * imported again.
+   *
+   * Source id -> import metadata
+   */
+  changedImportedSourceDataBySourceId: z69.record(ChangedImportedFigmaSourceData)
+});
+
+// src/dsm/import/support/import-model-collections.ts
+import { z as z77 } from "zod";
+
+// src/dsm/import/image.ts
+import { z as z70 } from "zod";
+var ImageImportModelType = z70.enum(["Url", "FigmaRender"]);
+var ImageImportModelBase = z70.object({
+  scope: AssetScope
+});
+var UrlImageImportModel = ImageImportModelBase.extend({
+  type: z70.literal(ImageImportModelType.enum.Url),
+  url: z70.string(),
+  originKey: z70.string(),
+  extension: z70.enum(["png", "svg", "jpg"])
+});
+var FigmaRenderFormat = z70.enum(["Svg", "Png"]);
+var FigmaRenderBase = ImageImportModelBase.extend({
+  type: z70.literal(ImageImportModelType.enum.FigmaRender),
+  fileId: z70.string(),
+  fileVersionId: z70.string().optional(),
+  nodeId: z70.string(),
+  originKey: z70.string()
+});
+var FigmaPngRenderImportModel = FigmaRenderBase.extend({
+  format: z70.literal(FigmaRenderFormat.enum.Png),
+  scale: z70.number()
+});
+var FigmaSvgRenderImportModel = FigmaRenderBase.extend({
+  format: z70.literal(FigmaRenderFormat.enum.Svg)
+});
+var FigmaRenderImportModel = z70.discriminatedUnion("format", [
+  FigmaPngRenderImportModel,
+  FigmaSvgRenderImportModel
+]);
+var ImageImportModel = z70.union([UrlImageImportModel, FigmaRenderImportModel]);
+
+// src/dsm/import/component.ts
+import { z as z72 } from "zod";
+
+// src/dsm/import/base.ts
+import { z as z71 } from "zod";
+var ImportModelBase = z71.object({
+  id: z71.string(),
+  meta: ObjectMeta,
+  origin: DesignElementOrigin,
+  brandPersistentId: z71.string(),
+  sortOrder: z71.number()
+});
+var ImportModelInputBase = ImportModelBase.omit({
+  brandPersistentId: true,
+  origin: true,
+  sortOrder: true
+}).extend({
+  originId: z71.string(),
+  originMetadata: z71.record(z71.any())
+});
+
+// src/dsm/import/component.ts
+var ComponentImportModelPart = z72.object({
+  thumbnail: ImageImportModel
+});
+var ComponentImportModel = ImportModelBase.extend(ComponentImportModelPart.shape).extend({
+  isAsset: z72.boolean(),
+  svg: FigmaSvgRenderImportModel.optional(),
+  origin: ComponentOrigin
+});
+var ComponentImportModelInput = ImportModelInputBase.extend(ComponentImportModelPart.shape).extend({
+  originMetadata: ComponentOriginPart
+});
+var AssetImportModelInput = ImportModelInputBase.extend(ComponentImportModelPart.shape).extend({
+  svg: FigmaSvgRenderImportModel,
+  originMetadata: ComponentOriginPart
+});
+
+// src/dsm/import/theme.ts
+import { z as z73 } from "zod";
+var ThemeOverrideImportModelBase = DesignTokenTypedData.and(
+  z73.object({
+    id: z73.string(),
+    meta: ObjectMeta
+  })
+);
+var ThemeOverrideImportModel = ThemeOverrideImportModelBase.and(
+  z73.object({
+    origin: ThemeOverrideOrigin
+  })
+);
+var ThemeOverrideImportModelInput = ThemeOverrideImportModelBase.and(
+  z73.object({
+    originId: z73.string(),
+    originMetadata: ThemeOverrideOriginPart
+  })
+);
+var ThemeImportModel = z73.object({
+  meta: ObjectMeta,
+  brandPersistentId: z73.string(),
+  originSource: ThemeOriginSource,
+  overrides: z73.array(ThemeOverrideImportModel),
+  sortOrder: z73.number()
+});
+var ThemeImportModelInput = z73.object({
+  meta: ObjectMeta,
+  originObjects: z73.array(ThemeOriginObject),
+  overrides: z73.array(ThemeOverrideImportModelInput)
+});
+var ThemeUpdateImportModel = z73.object({
+  themePersistentId: z73.string(),
+  overrides: z73.array(ThemeOverrideImportModel)
+});
+var ThemeUpdateImportModelInput = z73.object({
+  themePersistentId: z73.string(),
+  overrides: z73.array(ThemeOverrideImportModelInput)
+});
+
+// src/dsm/import/tokens.ts
+import { z as z74 } from "zod";
+var DesignTokenImportModelPart = z74.object({
+  collection: z74.string().optional()
+});
+var DesignTokenImportModelBase = ImportModelBase.extend(DesignTokenImportModelPart.shape).extend({
+  origin: DesignTokenOrigin
+});
+var DesignTokenImportModelInputBase = ImportModelInputBase.extend(DesignTokenImportModelPart.shape).extend({
+  originMetadata: DesignTokenOriginPart
+});
+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);
+}
+
+// src/dsm/import/figma-frames.ts
+import { z as z75 } from "zod";
+var FigmaFileStructureNodeImportModelBase = FigmaFileStructureNodeBase.extend({
+  image: FigmaPngRenderImportModel
+});
+var FigmaFileStructureNodeImportModel = FigmaFileStructureNodeImportModelBase.extend({
+  children: z75.lazy(() => FigmaFileStructureNodeImportModel.array())
+});
+var FigmaFileStructureImportModelPart = z75.object({
+  data: z75.object({
+    rootNode: FigmaFileStructureNodeImportModel,
+    assetsInFile: FigmaFileStructureStatistics
+  })
+});
+var FigmaFileStructureImportModel = ImportModelBase.extend(FigmaFileStructureImportModelPart.shape).extend({
+  origin: FigmaFileStructureOrigin
+});
+var FigmaFileStructureImportModelInput = ImportModelInputBase.extend(
+  FigmaFileStructureImportModelPart.shape
+).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);
+}
+
+// src/dsm/import/data-source.ts
+import { z as z76 } from "zod";
+var DataSourceImportModel = z76.object({
+  id: z76.string(),
+  fileName: z76.string().optional(),
+  thumbnailUrl: z76.string().optional()
+});
+
+// src/dsm/import/support/import-model-collections.ts
+var ImportModelInputCollection = z77.object({
+  source: DataSourceImportModel,
+  tokens: z77.array(DesignTokenImportModelInput).default([]),
+  components: z77.array(ComponentImportModelInput).default([]),
+  assets: z77.array(AssetImportModelInput).default([]),
+  themeUpdates: z77.array(ThemeUpdateImportModelInput).default([]),
+  themes: z77.array(ThemeImportModelInput).default([]),
+  figmaFileStructure: FigmaFileStructureImportModelInput.optional()
+});
+var ImportModelCollection = z77.object({
+  sources: z77.array(DataSourceImportModel),
+  tokens: z77.array(DesignTokenImportModel).default([]),
+  components: z77.array(ComponentImportModel).default([]),
+  themeUpdates: z77.array(ThemeUpdateImportModel).default([]),
+  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]
+  };
+}
+
+// src/dsm/import/warning.ts
+import { z as z78 } from "zod";
+var ImportWarningType = z78.enum([
+  "NoVersionFound",
+  "UnsupportedFill",
+  "UnsupportedStroke",
+  "UnsupportedEffect",
+  "NoPublishedElements",
+  "NoPublishedStyles",
+  "NoPublishedComponents",
+  "NoPublishedAssets",
+  "StyleNotApplied",
+  "ComponentHasNoThumbnail",
+  "DuplicateImportedStyleId",
+  "DuplicateImportedStylePath"
+]);
+var ImportWarning = z78.object({
+  warningType: ImportWarningType,
+  componentId: z78.string().optional(),
+  componentName: z78.string().optional(),
+  styleId: z78.string().optional(),
+  styleName: z78.string().optional(),
+  unsupportedStyleValueType: z78.string().optional()
+});
+
+// src/dsm/data-sources/import-summary.ts
+var FileStructureStats = z79.object({
+  frames: zeroNumberByDefault2(),
+  components: zeroNumberByDefault2(),
+  componentSets: zeroNumberByDefault2()
+});
+var SourceImportSummaryByTokenTypeKey = DesignTokenType.or(
+  // Backward compatibility
+  z79.enum(["Measure", "Radius", "GenericToken", "Font", "Text"])
+);
+var SourceImportSummaryByTokenType = z79.record(SourceImportSummaryByTokenTypeKey, z79.number());
+var SourceImportTokenSummary = z79.object({
+  tokensCreated: zeroNumberByDefault2(),
+  tokensUpdated: zeroNumberByDefault2(),
+  tokensDeleted: zeroNumberByDefault2(),
+  tokensCreatedPerType: SourceImportSummaryByTokenType.nullish().transform((v) => v ?? {}),
+  tokensUpdatedPerType: SourceImportSummaryByTokenType.nullish().transform((v) => v ?? {}),
+  tokensDeletedPerType: SourceImportSummaryByTokenType.nullish().transform((v) => v ?? {})
+});
+var SourceImportComponentSummary = z79.object({
+  componentsCreated: zeroNumberByDefault2(),
+  componentsUpdated: zeroNumberByDefault2(),
+  componentsDeleted: zeroNumberByDefault2(),
+  componentAssetsCreated: zeroNumberByDefault2(),
+  componentAssetsUpdated: zeroNumberByDefault2(),
+  componentAssetsDeleted: zeroNumberByDefault2()
+});
+var SourceImportFrameSummary = z79.object({
+  assetsInFile: nullishToOptional(FileStructureStats.optional()),
+  invalidReferencesCount: nullishToOptional(z79.number().optional())
+});
+var SourceImportSummary = z79.object({
+  sourceId: nullishToOptional(z79.string()),
+  brandId: nullishToOptional(z79.string()),
+  versionId: nullishToOptional(z79.string()),
+  error: nullishToOptional(z79.any()),
+  isFailed: z79.boolean(),
+  warnings: z79.array(ImportWarning).nullish().transform((v) => v ?? []),
+  ...SourceImportTokenSummary.shape,
+  ...SourceImportComponentSummary.shape,
+  ...FileStructureStats.shape
+});
+function zeroNumberByDefault2() {
+  return z79.number().nullish().transform((v) => v ?? 0);
+}
+
+// src/dsm/documentation/block-definitions/aux.ts
+import { z as z80 } from "zod";
+var PageBlockDefinitionAppearance = z80.object({
+  isBordered: z80.boolean().optional(),
+  hasBackground: z80.boolean().optional(),
+  isEditorPresentationDifferent: z80.boolean().optional()
+});
+
+// src/dsm/documentation/block-definitions/definition.ts
+import { z as z83 } from "zod";
+
+// src/dsm/documentation/block-definitions/item.ts
+import { z as z82 } from "zod";
+
+// src/dsm/documentation/block-definitions/variant.ts
+import { z as z81 } from "zod";
+var PageBlockDefinitionLayoutType = z81.enum(["Column", "Row"]);
+var PageBlockDefinitionLayoutGap = z81.enum(["Small", "Medium", "Large", "None"]);
+var PageBlockDefinitionLayoutAlign = z81.enum(["Start", "Center", "End"]);
+var PageBlockDefinitionLayoutResizing = z81.enum(["Fill", "Hug"]);
+var PageBlockDefinitionLayoutBase = z81.object({
+  type: PageBlockDefinitionLayoutType,
+  gap: PageBlockDefinitionLayoutGap.optional(),
+  columnAlign: PageBlockDefinitionLayoutAlign.optional(),
+  columnResizing: PageBlockDefinitionLayoutResizing.optional()
+});
+var PageBlockDefinitionLayout = PageBlockDefinitionLayoutBase.extend({
+  children: z81.lazy(() => z81.array(PageBlockDefinitionLayout.or(z81.string())))
+});
+var PageBlockDefinitionVariant = z81.object({
+  id: z81.string(),
+  name: z81.string(),
+  image: z81.string().optional(),
+  description: z81.string().optional(),
+  documentationLink: z81.string().optional(),
+  layout: PageBlockDefinitionLayout,
+  maxColumns: z81.number().optional(),
+  defaultColumns: z81.number().optional(),
+  appearance: PageBlockDefinitionAppearance.optional()
+});
+
+// src/dsm/documentation/block-definitions/item.ts
+var PageBlockDefinitionPropertyType = z82.enum([
+  "RichText",
+  "MultiRichText",
+  "Text",
+  "Boolean",
+  "Number",
+  "SingleSelect",
+  "MultiSelect",
+  "Image",
+  "Token",
+  "TokenType",
+  "TokenProperty",
+  "Component",
+  "ComponentProperty",
+  "Asset",
+  "AssetProperty",
+  "EmbedURL",
+  "URL",
+  "Markdown",
+  "Code",
+  "CodeSandbox",
+  "Table",
+  "Divider",
+  "Storybook",
+  "Color"
+]);
+var PageBlockDefinitionRichTextPropertyStyle = z82.enum([
+  "Title1",
+  "Title2",
+  "Title3",
+  "Title4",
+  "Title5",
+  "Quote",
+  "Callout",
+  "Default"
+]);
+var PageBlockDefinitionMultiRichTextPropertyStyle = z82.enum(["OL", "UL", "Default"]);
+var PageBlockDefinitionTextPropertyStyle = z82.enum([
+  "Title1",
+  "Title2",
+  "Title3",
+  "Title4",
+  "Title5",
+  "Default",
+  "DefaultBold",
+  "DefaultSemibold",
+  "Small",
+  "SmallBold",
+  "SmallSemibold"
+]);
+var PageBlockDefinitionBooleanPropertyStyle = z82.enum(["SegmentedControl", "ToggleButton", "Checkbox"]);
+var PageBlockDefinitionSingleSelectPropertyStyle = z82.enum([
+  "SegmentedControl",
+  "ToggleButton",
+  "Select",
+  "Checkbox"
+]);
+var PageBlockDefinitionMultiSelectPropertyStyle = z82.enum(["SegmentedControl", "Select", "Checkbox"]);
+var PageBlockDefinitionPropertyOptions = z82.object({
+  richTextStyle: PageBlockDefinitionRichTextPropertyStyle.optional(),
+  multiRichTextStyle: PageBlockDefinitionMultiRichTextPropertyStyle.optional(),
+  textStyle: PageBlockDefinitionTextPropertyStyle.optional(),
+  placeholder: z82.string().optional()
+}).and(z82.record(z82.any()));
+var PageBlockDefinitionProperty = z82.object({
+  id: z82.string(),
+  name: z82.string(),
+  type: PageBlockDefinitionPropertyType,
+  description: z82.string().optional(),
+  // TODO Docs
+  options: PageBlockDefinitionPropertyOptions.optional(),
+  variantOptions: z82.record(PageBlockDefinitionPropertyOptions).optional()
+});
+var PageBlockDefinitionItem = z82.object({
+  properties: z82.array(PageBlockDefinitionProperty),
+  appearance: PageBlockDefinitionAppearance.optional(),
+  variants: z82.array(PageBlockDefinitionVariant),
+  defaultVariantKey: z82.string()
+});
+
+// src/dsm/documentation/block-definitions/definition.ts
+var PageBlockCategory = z83.enum([
+  "Text",
+  "Layout",
+  "Media",
+  "Embed",
+  "Figma",
+  "Code",
+  "Guidelines",
+  "Tokens",
+  "Components",
+  "Assets",
+  "Data",
+  "Other"
+]);
+var PageBlockBehaviorDataType = z83.enum(["Item", "Token", "Asset", "Component", "FigmaFrame"]);
+var PageBlockBehaviorSelectionType = z83.enum(["Entity", "Group", "EntityAndGroup"]);
+var PageBlockDefinitionBehavior = z83.object({
+  dataType: PageBlockBehaviorDataType,
+  items: z83.object({
+    numberOfItems: z83.number(),
+    allowLinks: z83.boolean()
+  }).optional(),
+  entities: z83.object({
+    selectionType: PageBlockBehaviorSelectionType,
+    maxSelected: z83.number()
+  }).optional()
+});
+var PageBlockDefinitionOnboarding = z83.object({
+  helpText: z83.string(),
+  documentationLink: z83.string().optional()
+});
+var PageBlockDefinition = z83.object({
+  id: z83.string(),
+  name: z83.string(),
+  description: z83.string(),
+  category: PageBlockCategory,
+  icon: AssetValue.optional(),
+  documentationLink: z83.string().optional(),
+  searchKeywords: z83.array(z83.string()).optional(),
+  item: PageBlockDefinitionItem,
+  behavior: PageBlockDefinitionBehavior,
+  editorOptions: z83.object({
+    onboarding: PageBlockDefinitionOnboarding.optional()
+  }),
+  appearance: PageBlockDefinitionAppearance.optional()
+});
+
+// src/dsm/documentation/group.ts
+import { z as z84 } from "zod";
+var DocumentationPageGroup = z84.object({
+  type: z84.literal("ElementGroup"),
+  childType: z84.literal("DocumentationPage"),
+  id: z84.string(),
+  persistentId: z84.string(),
+  shortPersistentId: z84.string(),
+  designSystemVersionId: z84.string(),
+  parentPersistentId: z84.string().nullish(),
+  sortOrder: z84.number(),
+  title: z84.string(),
+  slug: z84.string(),
+  userSlug: z84.string().nullish(),
+  createdAt: z84.date(),
+  updatedAt: z84.date()
+});
+
+// src/dsm/documentation/page.ts
+import { z as z85 } from "zod";
+var DocumentationPage = z85.object({
+  type: z85.literal("DocumentationPage"),
+  id: z85.string(),
+  persistentId: z85.string(),
+  shortPersistentId: z85.string(),
+  designSystemVersionId: z85.string(),
+  parentPersistentId: z85.string().nullish(),
+  sortOrder: z85.number(),
+  title: z85.string(),
+  slug: z85.string(),
+  userSlug: z85.string().nullish(),
+  createdAt: z85.date(),
+  updatedAt: z85.date()
+});
+
+// src/dsm/design-system.ts
+import { z as z95 } from "zod";
+
+// src/workspace/npm-registry-settings.ts
+import { z as z86 } from "zod";
+var NpmRegistryAuthType = z86.enum(["Basic", "Bearer", "None", "Custom"]);
+var NpmRegistryType = z86.enum(["NPMJS", "GitHub", "AzureDevOps", "Artifactory", "Custom"]);
+var NpmRegistryBasicAuthConfig = z86.object({
+  authType: z86.literal(NpmRegistryAuthType.Enum.Basic),
+  username: z86.string(),
+  password: z86.string()
+});
+var NpmRegistryBearerAuthConfig = z86.object({
+  authType: z86.literal(NpmRegistryAuthType.Enum.Bearer),
+  accessToken: z86.string()
+});
+var NpmRegistryNoAuthConfig = z86.object({
+  authType: z86.literal(NpmRegistryAuthType.Enum.None)
+});
+var NpmRegistrCustomAuthConfig = z86.object({
+  authType: z86.literal(NpmRegistryAuthType.Enum.Custom),
+  authHeaderName: z86.string(),
+  authHeaderValue: z86.string()
+});
+var NpmRegistryAuthConfig = z86.discriminatedUnion("authType", [
+  NpmRegistryBasicAuthConfig,
+  NpmRegistryBearerAuthConfig,
+  NpmRegistryNoAuthConfig,
+  NpmRegistrCustomAuthConfig
+]);
+var NpmRegistryConfigBase = z86.object({
+  registryType: NpmRegistryType,
+  enabledScopes: z86.array(z86.string()),
+  customRegistryUrl: z86.string().optional(),
+  bypassProxy: z86.boolean().default(false),
+  npmProxyRegistryConfigId: z86.string().optional(),
+  npmProxyVersion: z86.number().optional()
+});
+var NpmRegistryConfig = NpmRegistryConfigBase.and(NpmRegistryAuthConfig);
+
+// src/workspace/sso-provider.ts
+import { z as z87 } from "zod";
+var SsoProvider = z87.object({
+  providerId: z87.string(),
+  defaultAutoInviteValue: z87.boolean(),
+  autoInviteDomains: z87.record(z87.string(), z87.boolean()),
+  skipDocsSupernovaLogin: z87.boolean(),
+  areInvitesDisabled: z87.boolean(),
+  isTestMode: z87.boolean(),
+  emailDomains: z87.array(z87.string()),
+  metadataXml: z87.string().nullish()
+});
+
+// src/workspace/user-invite.ts
+import { z as z89 } from "zod";
+
+// src/workspace/workspace-role.ts
+import { z as z88 } from "zod";
+var WorkspaceRoleSchema = z88.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Guest"]);
+var WorkspaceRole = WorkspaceRoleSchema.enum;
+
+// src/workspace/user-invite.ts
+var MAX_MEMBERS_COUNT = 100;
+var UserInvite = z89.object({
+  email: z89.string().email().trim().transform((value) => value.toLowerCase()),
+  role: WorkspaceRoleSchema
+});
+var UserInvites = z89.array(UserInvite).max(MAX_MEMBERS_COUNT);
+
+// src/workspace/workspace-context.ts
+import { z as z90 } from "zod";
+var WorkspaceContext = z90.object({
+  workspaceId: z90.string(),
+  product: ProductCodeSchema,
+  publicDesignSystem: z90.boolean().optional()
+});
+
+// src/workspace/workspace-create.ts
+import { z as z91 } from "zod";
+
+// src/utils/validation.ts
+var slugRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+
+// src/workspace/workspace-create.ts
+var WORKSPACE_NAME_MIN_LENGTH = 2;
+var WORKSPACE_NAME_MAX_LENGTH = 64;
+var HANDLE_MIN_LENGTH = 2;
+var HANDLE_MAX_LENGTH = 64;
+var CreateWorkspaceInput = z91.object({
+  name: z91.string().min(WORKSPACE_NAME_MIN_LENGTH).max(WORKSPACE_NAME_MAX_LENGTH).trim(),
+  product: ProductCodeSchema,
+  priceId: z91.string(),
+  billingEmail: z91.string().email().optional(),
+  handle: z91.string().regex(slugRegex).min(HANDLE_MIN_LENGTH).max(HANDLE_MAX_LENGTH).refine((value) => value?.length > 0).optional(),
+  invites: UserInvites.optional(),
+  promoCode: z91.string().optional()
+});
+
+// src/workspace/workspace-invitations.ts
+import { z as z92 } from "zod";
+var WorkspaceInvitation = z92.object({
+  id: z92.string(),
+  email: z92.string().email(),
+  createdAt: z92.date(),
+  resentAt: z92.date().nullish(),
+  role: z92.nativeEnum(WorkspaceRole),
+  workspaceId: z92.string(),
+  invitedBy: z92.string()
+});
+
+// src/workspace/workspace-membership.ts
+import { z as z93 } from "zod";
+var WorkspaceMembership = z93.object({
+  id: z93.string(),
+  userId: z93.string(),
+  workspaceId: z93.string(),
+  workspaceRole: z93.nativeEnum(WorkspaceRole)
+});
+
+// src/workspace/workspace.ts
+import { z as z94 } from "zod";
+var WorkspaceIpWhitelistEntry = z94.object({
+  isEnabled: z94.boolean(),
+  name: z94.string(),
+  range: z94.string()
+});
+var WorkspaceIpSettings = z94.object({
+  isEnabledForCloud: z94.boolean(),
+  isEnabledForDocs: z94.boolean(),
+  entries: z94.array(WorkspaceIpWhitelistEntry)
+}).nullish();
+var WorkspaceProfile = z94.object({
+  name: z94.string(),
+  handle: z94.string(),
+  color: z94.string(),
+  avatar: z94.string().optional(),
+  billingDetails: BillingDetails.optional()
+});
+var Workspace = z94.object({
+  id: z94.string(),
+  profile: WorkspaceProfile,
+  subscription: Subscription,
+  ipWhitelist: WorkspaceIpSettings,
+  sso: SsoProvider.nullish(),
+  npmRegistrySettings: z94.unknown().optional(),
+  designSystems: z94.array(DesignSystem).nullish()
+});
+var WorkspaceWithDesignSystems = z94.object({
+  workspace: Workspace,
+  designSystems: z94.array(DesignSystem)
+});
+
+// src/dsm/design-system.ts
+var DesignSystemSwitcher = z95.object({
+  isEnabled: z95.boolean(),
+  designSystemIds: z95.string()
+});
+var DesignSystem = z95.object({
+  id: z95.string(),
+  workspaceId: z95.string(),
+  name: z95.string(),
+  description: z95.string(),
+  docExporterId: z95.string().nullish(),
+  docSlug: z95.string(),
+  docUserSlug: z95.string().nullish(),
+  docSlugDeprecated: z95.string(),
+  isPublic: z95.boolean(),
+  isMultibrand: z95.boolean(),
+  docViewUrl: z95.string().nullish(),
+  basePrefixes: z95.array(z95.string()),
+  designSystemSwitcher: DesignSystemSwitcher.nullish(),
+  createdAt: z95.date(),
+  updatedAt: z95.date()
+});
+var DesignSystemWithWorkspace = z95.object({
+  designSystem: DesignSystem,
+  workspace: Workspace
+});
+
+// src/dsm/desing-system-create.ts
+import { z as z96 } from "zod";
+var DS_NAME_MIN_LENGTH = 2;
+var DS_NAME_MAX_LENGTH = 64;
+var DS_DESC_MIN_LENGTH = 2;
+var DS_DESC_MAX_LENGTH = 64;
+var DesignSystemCreateInputMetadata = z96.object({
+  name: z96.string().min(DS_NAME_MIN_LENGTH).max(DS_NAME_MAX_LENGTH).trim(),
+  description: z96.string().min(DS_DESC_MIN_LENGTH).max(DS_DESC_MAX_LENGTH).trim()
+});
+var DesignSystemCreateInput = z96.object({
+  meta: DesignSystemCreateInputMetadata,
+  workspaceId: z96.string(),
+  isPublic: z96.boolean().optional(),
+  basePrefixes: z96.array(z96.string()).optional(),
+  docUserSlug: z96.string().nullish().optional(),
+  source: z96.array(z96.string()).optional()
+});
+
+// src/dsm/desing-system-update.ts
+import { z as z97 } from "zod";
+var DS_NAME_MIN_LENGTH2 = 2;
+var DS_NAME_MAX_LENGTH2 = 64;
+var DS_DESC_MIN_LENGTH2 = 2;
+var DS_DESC_MAX_LENGTH2 = 64;
+var DesignSystemUpdateInputMetadata = z97.object({
+  name: z97.string().min(DS_NAME_MIN_LENGTH2).max(DS_NAME_MAX_LENGTH2).trim().optional(),
+  description: z97.string().min(DS_DESC_MIN_LENGTH2).max(DS_DESC_MAX_LENGTH2).trim().optional()
+});
+var DesignSystemUpdateInput = z97.object({
+  meta: DesignSystemUpdateInputMetadata.optional(),
+  workspaceId: z97.string().optional(),
+  isPublic: z97.boolean().optional(),
+  basePrefixes: z97.array(z97.string()).optional(),
+  docUserSlug: z97.string().nullish().optional(),
+  source: z97.array(z97.string()).optional(),
+  name: z97.string().min(DS_NAME_MIN_LENGTH2).max(DS_NAME_MAX_LENGTH2).trim().optional(),
+  description: z97.string().min(DS_DESC_MIN_LENGTH2).max(DS_DESC_MAX_LENGTH2).trim().optional(),
+  docExporterId: z97.string().optional()
+});
+
+// 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;
+}
+
+// src/dsm/published-doc.ts
+import { z as z98 } from "zod";
+var publishedDocEnvironments = ["Live", "Preview"];
+var PublishedDocEnvironment = z98.enum(publishedDocEnvironments);
+var PublishedDocsChecksums = z98.record(z98.string());
+var PublishedDocRoutingVersion = z98.enum(["1", "2"]);
+var PublishedDoc = z98.object({
+  id: z98.string(),
+  designSystemVersionId: z98.string(),
+  createdAt: z98.date(),
+  updatedAt: z98.date(),
+  lastPublishedAt: z98.date(),
+  isDefault: z98.boolean(),
+  isPublic: z98.boolean(),
+  environment: PublishedDocEnvironment,
+  checksums: PublishedDocsChecksums,
+  storagePath: z98.string(),
+  wasMigrated: z98.boolean(),
+  routingVersion: PublishedDocRoutingVersion,
+  usesLocalizations: z98.boolean(),
+  wasPublishedWithLocalizations: z98.boolean()
+});
+
+// src/codegen/export-jobs.ts
+import { z as z99 } from "zod";
+var ExportJobStatus = z99.union([
+  z99.literal("Success"),
+  z99.literal("InProgress"),
+  z99.literal("Timeout"),
+  z99.literal("Failed")
+]);
+var ExportJob = z99.object({
+  id: z99.string(),
+  workspaceId: z99.string(),
+  designSystemId: z99.string(),
+  designSystemVersionId: z99.string(),
+  status: ExportJobStatus,
+  docsUrl: z99.string().nullish(),
+  scheduleId: z99.string().nullish(),
+  exporterId: z99.string().nullish(),
+  createdAt: z99.date(),
+  environment: PublishedDocEnvironment,
+  finishedAt: z99.date().nullish()
+});
+
+// src/codegen/exporter-workspace-membership-role.ts
+import { z as z100 } from "zod";
+var ExporterWorkspaceMembershipRole = z100.enum(["Owner", "OwnerArchived", "User"]);
+
+// src/codegen/exporter-workspace-membership.ts
+import { z as z101 } from "zod";
+var ExporterWorkspaceMembership = z101.object({
+  id: z101.string(),
+  workspaceId: z101.string(),
+  exporterId: z101.string(),
+  role: ExporterWorkspaceMembershipRole
+});
+
+// src/codegen/exporter.ts
+import { z as z104 } from "zod";
+
+// src/codegen/git-providers.ts
+import { z as z102 } from "zod";
+var GitProviderNames = /* @__PURE__ */ ((GitProviderNames2) => {
+  GitProviderNames2["Azure"] = "azure";
+  GitProviderNames2["Github"] = "github";
+  GitProviderNames2["Gitlab"] = "gitlab";
+  GitProviderNames2["Bitbucket"] = "bitbucket";
+  return GitProviderNames2;
+})(GitProviderNames || {});
+var GitProvider = z102.nativeEnum(GitProviderNames);
+
+// src/codegen/pulsar.ts
+import { z as z103 } from "zod";
+var PulsarContributionVariant = z103.object({
+  key: z103.string(),
+  name: z103.string(),
+  isDefault: z103.boolean().optional(),
+  description: z103.string().optional(),
+  thumbnailURL: z103.string().optional()
+});
+var PulsarPropertyType = z103.enum([
+  "string",
+  "number",
+  "boolean",
+  "image",
+  "enum",
+  "color",
+  "typography",
+  "component",
+  "componentProperties",
+  "tokenProperties",
+  "tokenType"
+]);
+var BasePulsarProperty = z103.object({
+  label: z103.string(),
+  key: z103.string(),
+  description: z103.string().optional(),
+  type: PulsarPropertyType,
+  values: z103.array(z103.string()).optional(),
+  default: z103.union([z103.string(), z103.boolean(), z103.number()]).nullish(),
+  // PulsarPropertyValueType //is optional?
+  inputType: z103.enum(["code", "plain"]).optional(),
+  //is optional?
+  isMultiline: z103.boolean().optional()
+});
+var PulsarContributionBlock = z103.object({
+  title: z103.string(),
+  key: z103.string(),
+  category: z103.string(),
+  description: z103.string().optional(),
+  iconURL: z103.string(),
+  mode: z103.enum(["array", "block"]),
+  properties: z103.array(BasePulsarProperty)
+});
+var PulsarContributionConfigurationProperty = BasePulsarProperty.extend({ category: z103.string() });
+
+// src/codegen/exporter.ts
+var ExporterType = z104.enum(["code", "documentation"]);
+var ExporterSource = z104.enum(["git", "upload"]);
+var ExporterTag = z104.string().regex(/^[0-9a-zA-Z]+(\s[0-9a-zA-Z]+)*$/);
+var ExporterDetails = z104.object({
+  packageId: z104.string().max(255),
+  version: z104.string(),
+  description: z104.string(),
+  author: nullishToOptional(z104.string()),
+  organization: nullishToOptional(z104.string()),
+  homepage: nullishToOptional(z104.string()),
+  readme: nullishToOptional(z104.string()),
+  tags: z104.array(ExporterTag).default([]),
+  routingVersion: nullishToOptional(z104.string()),
+  iconURL: nullishToOptional(z104.string()),
+  configurationProperties: z104.array(PulsarContributionConfigurationProperty).default([]),
+  customBlocks: z104.array(PulsarContributionBlock).default([]),
+  blockVariants: z104.record(z104.string(), z104.array(PulsarContributionVariant)).default({}),
+  usesBrands: z104.boolean().default(false),
+  usesThemes: z104.boolean().default(false),
+  source: ExporterSource,
+  gitProvider: nullishToOptional(GitProvider),
+  gitUrl: nullishToOptional(z104.string()),
+  gitBranch: nullishToOptional(z104.string()),
+  gitDirectory: nullishToOptional(z104.string())
+});
+var Exporter = z104.object({
+  id: z104.string(),
+  createdAt: z104.coerce.date(),
+  name: z104.string(),
+  isPrivate: z104.boolean(),
+  details: ExporterDetails,
+  exporterType: ExporterType.default("code"),
+  storagePath: z104.string().default("")
+});
+
+// src/custom-domains/custom-domains.ts
+import { z as z105 } from "zod";
+var CustomDomain = z105.object({
+  id: z105.string(),
+  designSystemId: z105.string(),
+  state: z105.string(),
+  supernovaDomain: z105.string(),
+  customerDomain: z105.string().nullish(),
+  error: z105.string().nullish(),
+  errorCode: z105.string().nullish()
+});
+
+// src/docs-server/session.ts
+import { z as z110 } from "zod";
+
+// src/users/linked-integrations.ts
+import { z as z106 } from "zod";
+var IntegrationAuthType = z106.union([z106.literal("OAuth2"), z106.literal("PAT")]);
+var ExternalServiceType = z106.union([
+  z106.literal("figma"),
+  z106.literal("github"),
+  z106.literal("azure"),
+  z106.literal("gitlab"),
+  z106.literal("bitbucket")
+]);
+var IntegrationUserInfo = z106.object({
+  id: z106.string(),
+  handle: z106.string().optional(),
+  avatarUrl: z106.string().optional(),
+  email: z106.string().optional(),
+  authType: IntegrationAuthType.optional(),
+  customUrl: z106.string().optional()
+});
+var UserLinkedIntegrations = z106.object({
+  figma: IntegrationUserInfo.optional(),
+  github: IntegrationUserInfo.array().optional(),
+  azure: IntegrationUserInfo.array().optional(),
+  gitlab: IntegrationUserInfo.array().optional(),
+  bitbucket: IntegrationUserInfo.array().optional()
+});
+
+// src/users/user-identity.ts
+import { z as z107 } from "zod";
+var UserIdentity = z107.object({
+  id: z107.string(),
+  userId: z107.string()
+});
+
+// src/users/user-profile.ts
+import { z as z108 } from "zod";
+var UserOnboardingDepartment = z108.enum(["Design", "Engineering", "Brand", "Other"]);
+var UserOnboardingJobLevel = z108.enum(["Executive", "Manager", "IndividualContributor", "Other"]);
+var UserOnboarding = z108.object({
+  companyName: z108.string().optional(),
+  numberOfPeopleInOrg: z108.string().optional(),
+  numberOfPeopleInDesignTeam: z108.string().optional(),
+  department: UserOnboardingDepartment.optional(),
+  jobTitle: z108.string().optional(),
+  phase: z108.string().optional(),
+  jobLevel: UserOnboardingJobLevel.optional()
+});
+var UserProfile = z108.object({
+  name: z108.string(),
+  avatar: z108.string().optional(),
+  nickname: z108.string().optional(),
+  onboarding: UserOnboarding.optional()
+});
+
+// src/users/user.ts
+import { z as z109 } from "zod";
+var User = z109.object({
+  id: z109.string(),
+  email: z109.string(),
+  emailVerified: z109.boolean(),
+  createdAt: z109.date(),
+  trialExpiresAt: z109.date().optional(),
+  profile: UserProfile,
+  linkedIntegrations: UserLinkedIntegrations.optional(),
+  loggedOutAt: z109.date().optional(),
+  isProtected: z109.boolean()
+});
+
+// src/docs-server/session.ts
+var NpmProxyToken = z110.object({
+  access: z110.string(),
+  expiresAt: z110.number()
+});
+var SessionData = z110.object({
+  returnToUrl: z110.string().optional(),
+  npmProxyToken: NpmProxyToken.optional()
+});
+var Session = z110.object({
+  id: z110.string(),
+  expiresAt: z110.date(),
+  userId: z110.string().nullable(),
+  data: SessionData
+});
+var AuthTokens = z110.object({
+  access: z110.string(),
+  refresh: z110.string()
+});
+var UserSession = z110.object({
+  session: Session,
+  user: User.nullable()
+});
+
+// src/feature-flags/feature-flags.ts
+import { z as z111 } from "zod";
+var FlaggedFeature = z111.enum(["FigmaImporterV2"]);
+var FeatureFlagMap = z111.record(FlaggedFeature, z111.boolean());
+var FeatureFlag = z111.object({
+  id: z111.string(),
+  feature: FlaggedFeature,
+  createdAt: z111.date(),
+  enabled: z111.boolean()
+});
+
+// src/integrations/external-oauth-request.ts
+import { z as z113 } from "zod";
+
+// src/integrations/oauth-providers.ts
+import { z as z112 } from "zod";
+var OAuthProviderNames = /* @__PURE__ */ ((OAuthProviderNames2) => {
+  OAuthProviderNames2["Figma"] = "figma";
+  OAuthProviderNames2["Azure"] = "azure";
+  OAuthProviderNames2["Github"] = "github";
+  OAuthProviderNames2["Gitlab"] = "gitlab";
+  OAuthProviderNames2["Bitbucket"] = "bitbucket";
+  return OAuthProviderNames2;
+})(OAuthProviderNames || {});
+var OAuthProviderSchema = z112.nativeEnum(OAuthProviderNames);
+var OAuthProvider = OAuthProviderSchema.enum;
+
+// src/integrations/external-oauth-request.ts
+var ExternalOAuthRequest = z113.object({
+  id: z113.string(),
+  provider: OAuthProviderSchema,
+  userId: z113.string(),
+  state: z113.string(),
+  createdAt: z113.date()
+});
+
+// src/integrations/oauth-token.ts
+import { z as z114 } from "zod";
+var IntegrationTokenSchema = z114.object({
+  id: z114.string(),
+  provider: OAuthProviderSchema,
+  scope: z114.string(),
+  userId: z114.string(),
+  accessToken: z114.string(),
+  refreshToken: z114.string(),
+  expiresAt: z114.date(),
+  externalUserId: z114.string().nullish()
+});
+
+// src/multiplayer/design-system-version-room.ts
+import { z as z115 } from "zod";
+var DesignSystemVersionRoom = Entity.extend({
+  designSystemVersionId: z115.string(),
+  liveblocksId: z115.string()
+});
+
+// src/multiplayer/documentation-page-room.ts
+import { z as z116 } from "zod";
+var DocumentationPageRoom = Entity.extend({
+  designSystemVersionId: z116.string(),
+  documentationPageId: z116.string(),
+  liveblocksId: z116.string()
+});
+
+// src/npm/npm-package.ts
+import { z as z117 } from "zod";
+var AnyRecord = z117.record(z117.any());
+var NpmPackageVersionDist = AnyRecord.and(
+  z117.object({
+    tarball: z117.string()
+  })
+);
+var NpmPackageVersion = AnyRecord.and(
+  z117.object({
+    dist: NpmPackageVersionDist
+  })
+);
+var NpmPackage = AnyRecord.and(
+  z117.object({
+    _id: z117.string(),
+    name: z117.string(),
+    // e.g. "latest": "1.2.3"
+    "dist-tags": z117.record(z117.string(), z117.string()),
+    // "1.2.3": {...}
+    versions: z117.record(NpmPackageVersion)
+  })
+);
+
+// src/npm/npm-proxy-token-payload.ts
+import { z as z118 } from "zod";
+var NpmProxyTokenPayload = z118.object({
+  npmProxyRegistryConfigId: z118.string()
+});
+
+// src/tokens/personal-access-token.ts
+import { z as z119 } from "zod";
+var PersonalAccessToken = z119.object({
+  id: z119.string(),
+  userId: z119.string(),
+  name: z119.string(),
+  token: z119.string(),
+  createdAt: z119.date(),
+  hidden: z119.boolean(),
+  workspaceId: z119.string().optional(),
+  workspaceRole: WorkspaceRoleSchema.optional(),
+  expireAt: z119.date().optional(),
+  scope: z119.string().optional()
+});
+
+// src/utils/content-loader-instruction.ts
+import { z as z120 } from "zod";
+var ContentLoadInstruction = z120.object({
+  from: z120.string(),
+  to: z120.string(),
+  authorizationHeaderKvsId: z120.string().optional(),
+  timeout: z120.number().optional()
+});
+var ContentLoaderPayload = z120.object({
+  type: z120.literal("Single"),
+  instruction: ContentLoadInstruction
+}).or(
+  z120.object({
+    type: z120.literal("Multiple"),
+    loadingChunkSize: z120.number().optional(),
+    instructions: z120.array(ContentLoadInstruction)
+  })
+).or(
+  z120.object({
+    type: z120.literal("S3"),
+    location: z120.string()
+  })
+);
+export {
+  Address,
+  Asset,
+  AssetFontProperties,
+  AssetImportModelInput,
+  AssetOrigin,
+  AssetProperties,
+  AssetReference,
+  AssetScope,
+  AssetType,
+  AssetValue,
+  AuthTokens,
+  BasePulsarProperty,
+  BillingDetails,
+  BillingIntervalSchema,
+  BillingType,
+  BillingTypeSchema,
+  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,
+  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,
+  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,
+  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,
+  designTokenImportModelTypeFilter,
+  designTokenTypeFilter,
+  extractTokenTypedData,
+  figmaFileStructureImportModelToMap,
+  figmaFileStructureToMap,
+  isDesignTokenImportModelOfType,
+  isDesignTokenOfType,
+  isImportedAsset,
+  isImportedComponent,
+  isImportedDesignToken,
+  isTokenType,
+  nullishToOptional,
+  publishedDocEnvironments,
+  tokenAliasOrValue,
+  tokenElementTypes,
+  traversePageBlocksV1,
+  traverseStructure,
+  tryParseShortPersistentId,
+  zodCreateInputOmit,
+  zodUpdateInputOmit
+};
+//# sourceMappingURL=index.mjs.map