@supernova-studio/model 0.0.4

package/src/dsm/elements/data/duration.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const DurationUnit = z.enum(["Ms"]);
+
+export const DurationValue = z.object({
+  unit: DurationUnit,
+  measure: z.number(),
+});
+
+export const DurationTokenData = tokenAliasOrValue(DurationValue);
+
+export type DurationUnit = z.infer<typeof DurationUnit>;
+export type DurationValue = z.infer<typeof DurationValue>;
+export type DurationTokenData = z.infer<typeof DurationTokenData>;

package/src/dsm/elements/data/figma-file-structure.ts

@@ -0,0 +1,65 @@
+import { ZodTypeDef, z } from "zod";
+import { Size, SizeOrUndefined } from "../primitives/size";
+
+export const FigmaFileStructureNodeType = z.enum(["DOCUMENT", "CANVAS", "FRAME", "COMPONENT", "COMPONENT_SET"]);
+
+export const FigmaFileStructureNodeBase = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: FigmaFileStructureNodeType,
+  size: SizeOrUndefined,
+  parentComponentSetId: z.string().optional(),
+});
+
+export const FigmaFileStructureNode: z.ZodType<FigmaFileStructureNode, ZodTypeDef, FigmaFileStructureNodeBaseInput> =
+  FigmaFileStructureNodeBase.extend({
+    children: z.lazy(() => FigmaFileStructureNode.array()),
+  });
+
+type FigmaFileStructureNodeBaseInput = z.input<typeof FigmaFileStructureNodeBase> & {
+  children: FigmaFileStructureNodeBaseInput[];
+};
+
+export const FigmaFileStructureStatistics = z.object({
+  frames: z
+    .number()
+    .nullable()
+    .optional()
+    .transform(v => v ?? 0),
+  components: z
+    .number()
+    .nullable()
+    .optional()
+    .transform(v => v ?? 0),
+  componentSets: z
+    .number()
+    .nullable()
+    .optional()
+    .transform(v => v ?? 0),
+});
+
+export const FigmaFileStructureElementData = z.object({
+  value: z.object({
+    structure: FigmaFileStructureNode,
+    assetsInFile: FigmaFileStructureStatistics,
+  }),
+});
+
+export type FigmaFileStructureNodeBase = z.infer<typeof FigmaFileStructureNodeBase>;
+export type FigmaFileStructureNodeType = z.infer<typeof FigmaFileStructureStatistics>;
+export type FigmaFileStructureNode = z.infer<typeof FigmaFileStructureNodeBase> & {
+  children: FigmaFileStructureNode[];
+};
+export type FigmaFileStructureStatistics = z.infer<typeof FigmaFileStructureStatistics>;
+export type FigmaFileStructureElementData = z.infer<typeof FigmaFileStructureElementData>;
+
+export function figmaFileStructureToMap(root: FigmaFileStructureNode): Map<string, FigmaFileStructureNode> {
+  const map = new Map<string, FigmaFileStructureNode>();
+  recursiveFigmaFileStructureToMap(root, map);
+  return map;
+}
+
+function recursiveFigmaFileStructureToMap(node: FigmaFileStructureNode, map: Map<string, FigmaFileStructureNode>) {
+  map.set(node.id, node);
+  for (const child of node.children) recursiveFigmaFileStructureToMap(child, map);
+}

package/src/dsm/elements/data/figma-node-reference.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+export const FigmaNodeReferenceData = z.object({
+  structureElementId: z.string(),
+  nodeId: z.string(),
+  fileId: z.string().optional(),
+  valid: z.boolean(),
+  assetId: z.string().optional(),
+  assetScale: z.number().optional(),
+  assetWidth: z.number().optional(),
+  assetHeight: z.number().optional(),
+  assetUrl: z.string().optional(),
+});
+
+export const FigmaNodeReferenceElementData = z.object({
+  value: FigmaNodeReferenceData,
+});
+
+export type FigmaNodeReferenceData = z.infer<typeof FigmaNodeReferenceData>;
+export type FigmaNodeReferenceElementData = z.infer<typeof FigmaNodeReferenceElementData>;

package/src/dsm/elements/data/font-family.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const FontFamilyValue = z.string();
+export const FontFamilyTokenData = tokenAliasOrValue(FontFamilyValue);
+
+export type FontFamilyValue = z.infer<typeof FontFamilyValue>;
+export type FontFamilyTokenData = z.infer<typeof FontFamilyTokenData>;

package/src/dsm/elements/data/font-size.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const FontSizeUnit = z.enum(["Pixels", "Rem", "Percent"]);
+
+export const FontSizeValue = z.object({
+  unit: FontSizeUnit,
+  measure: z.number(),
+});
+
+export const FontSizeTokenData = tokenAliasOrValue(FontSizeValue);
+
+export type FontSizeUnit = z.infer<typeof FontSizeUnit>;
+export type FontSizeValue = z.infer<typeof FontSizeValue>;
+export type FontSizeTokenData = z.infer<typeof FontSizeTokenData>;

package/src/dsm/elements/data/font-weight.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const FontWeightValue = z.string();
+export const FontWeightTokenData = tokenAliasOrValue(FontWeightValue);
+
+export type FontWeightValue = z.infer<typeof FontWeightValue>;
+export type FontWeightTokenData = z.infer<typeof FontWeightTokenData>;

package/src/dsm/elements/data/gradient.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { ColorTokenData } from "./color";
+import { tokenAliasOrValue } from "./base";
+import { nullishToOptional } from "../../../helpers";
+import { Point2D } from "../primitives";
+
+export const GradientType = z.enum(["Linear", "Radial", "Angular"]);
+
+export const GradientStop = z.object({
+  position: z.number(),
+  color: ColorTokenData,
+});
+
+export const GradientLayerValue = z.object({
+  from: Point2D,
+  to: Point2D,
+  type: GradientType,
+  aspectRatio: nullishToOptional(z.number()), // z.number(),
+  stops: z.array(GradientStop).min(2),
+});
+
+export const GradientLayerData = tokenAliasOrValue(GradientLayerValue);
+
+export const GradientTokenValue = z.array(GradientLayerData);
+export const GradientTokenData = tokenAliasOrValue(GradientTokenValue);
+
+export type GradientType = z.infer<typeof GradientType>;
+export type GradientStop = z.infer<typeof GradientStop>;
+export type GradientLayerValue = z.infer<typeof GradientLayerValue>;
+export type GradientLayerData = z.infer<typeof GradientLayerData>;
+export type GradientTokenValue = z.infer<typeof GradientTokenValue>;
+export type GradientTokenData = z.infer<typeof GradientTokenData>;

package/src/dsm/elements/data/group.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { nullishToOptional } from "../../../helpers";
+import { DocumentationItemConfiguration } from "./documentation";
+
+export const DocumentationGroupBehavior = z.enum(["Group", "Tabs"]);
+
+export const ElementGroupData = z.object({
+  behavior: nullishToOptional(DocumentationGroupBehavior.optional()),
+  configuration: nullishToOptional(DocumentationItemConfiguration),
+});
+
+export const ElementGroupElementData = z.object({
+  value: ElementGroupData.optional(),
+});
+
+export type DocumentationGroupBehavior = z.infer<typeof DocumentationGroupBehavior>;
+export type ElementGroupData = z.infer<typeof ElementGroupData>;

package/src/dsm/elements/data/index.ts

@@ -0,0 +1,36 @@
+export * from "./base";
+export * from "./blur";
+export * from "./border-radius";
+export * from "./border-width";
+export * from "./border";
+export * from "./color";
+export * from "./component";
+export * from "./dimension";
+export * from "./documentation-block-v1";
+export * from "./documentation-block-v2";
+export * from "./documentation-page-v1";
+export * from "./documentation-page-v2";
+export * from "./documentation";
+export * from "./duration";
+export * from "./figma-file-structure";
+export * from "./figma-node-reference";
+export * from "./font-family";
+export * from "./font-size";
+export * from "./font-weight";
+export * from "./gradient";
+export * from "./group";
+export * from "./letter-spacing";
+export * from "./line-height";
+export * from "./opacity";
+export * from "./paragraph-indent";
+export * from "./paragraph-spacing";
+export * from "./product-copy";
+export * from "./shadow";
+export * from "./size";
+export * from "./space";
+export * from "./string";
+export * from "./text-case";
+export * from "./text-decoration";
+export * from "./typography";
+export * from "./visibility";
+export * from "./z-index";

package/src/dsm/elements/data/letter-spacing.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const LetterSpacingUnit = z.enum(["Pixels", "Rem", "Percent"]);
+
+export const LetterSpacingValue = z.object({
+  unit: LetterSpacingUnit,
+  measure: z.number(),
+});
+
+export const LetterSpacingTokenData = tokenAliasOrValue(LetterSpacingValue);
+
+export type LetterSpacingUnit = z.infer<typeof LetterSpacingUnit>;
+export type LetterSpacingValue = z.infer<typeof LetterSpacingValue>;
+export type LetterSpacingTokenData = z.infer<typeof LetterSpacingTokenData>;

package/src/dsm/elements/data/line-height.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const LineHeightUnit = z.enum(["Pixels", "Rem", "Percent", "Raw"]);
+
+export const LineHeightValue = z.object({
+  unit: LineHeightUnit,
+  measure: z.number(),
+});
+
+export const LineHeightTokenData = tokenAliasOrValue(LineHeightValue);
+
+export type LineHeightUnit = z.infer<typeof LineHeightUnit>;
+export type LineHeightValue = z.infer<typeof LineHeightValue>;
+export type LineHeightTokenData = z.infer<typeof LineHeightTokenData>;

package/src/dsm/elements/data/opacity.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const OpacityValue = z.object({
+  unit: z.enum(["Raw", "Pixels"]),
+  measure: z.number(),
+});
+
+export const OpacityTokenData = tokenAliasOrValue(OpacityValue);
+
+export type OpacityValue = z.infer<typeof OpacityValue>;
+export type OpacityTokenData = z.infer<typeof OpacityTokenData>;

package/src/dsm/elements/data/paragraph-indent.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const ParagraphIndentUnit = z.enum(["Pixels", "Rem", "Percent"]);
+
+export const ParagraphIndentValue = z.object({
+  unit: ParagraphIndentUnit,
+  measure: z.number(),
+});
+
+export const ParagraphIndentTokenData = tokenAliasOrValue(ParagraphIndentValue);
+
+export type ParagraphIndentUnit = z.infer<typeof ParagraphIndentUnit>;
+export type ParagraphIndentValue = z.infer<typeof ParagraphIndentValue>;
+export type ParagraphIndentTokenData = z.infer<typeof ParagraphIndentTokenData>;

package/src/dsm/elements/data/paragraph-spacing.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const ParagraphSpacingUnit = z.enum(["Pixels", "Rem", "Percent"]);
+
+export const ParagraphSpacingValue = z.object({
+  unit: ParagraphSpacingUnit,
+  measure: z.number(),
+});
+
+export const ParagraphSpacingTokenData = tokenAliasOrValue(ParagraphSpacingValue);
+
+export type ParagraphSpacingUnit = z.infer<typeof ParagraphSpacingUnit>;
+export type ParagraphSpacingValue = z.infer<typeof ParagraphSpacingValue>;
+export type ParagraphSpacingTokenData = z.infer<typeof ParagraphSpacingTokenData>;

package/src/dsm/elements/data/product-copy.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const ProductCopyValue = z.string();
+export const ProductCopyTokenData = tokenAliasOrValue(ProductCopyValue);
+
+export type ProductCopyValue = z.infer<typeof ProductCopyValue>;
+export type ProductCopyTokenData = z.infer<typeof ProductCopyTokenData>;

package/src/dsm/elements/data/shadow.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { ColorTokenData } from "./color";
+import { OpacityTokenData } from "./opacity";
+import { tokenAliasOrValue } from "./base";
+
+export const ShadowType = z.enum(["Drop", "Inner"]);
+
+export const ShadowLayerValue = z.object({
+  color: ColorTokenData,
+  x: z.number(),
+  y: z.number(),
+  radius: z.number(),
+  spread: z.number(),
+  opacity: OpacityTokenData,
+  type: ShadowType,
+});
+
+const ShadowTokenDataBase = tokenAliasOrValue(ShadowLayerValue);
+export const ShadowTokenData = tokenAliasOrValue(z.array(ShadowTokenDataBase));
+
+export type ShadowType = z.infer<typeof ShadowType>;
+export type ShadowLayerValue = z.infer<typeof ShadowLayerValue>;
+export type ShadowTokenData = z.infer<typeof ShadowTokenData>;

package/src/dsm/elements/data/size.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const SizeUnit = z.enum(["Pixels", "Rem", "Percent"]);
+
+export const SizeValue = z.object({
+  unit: SizeUnit,
+  measure: z.number(),
+});
+
+export const SizeTokenData = tokenAliasOrValue(SizeValue);
+
+export type SizeUnit = z.infer<typeof SizeUnit>;
+export type SizeValue = z.infer<typeof SizeValue>;
+export type SizeTokenData = z.infer<typeof SizeTokenData>;

package/src/dsm/elements/data/space.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const SpaceUnit = z.enum(["Pixels", "Rem", "Percent"]);
+
+export const SpaceValue = z.object({
+  unit: SpaceUnit,
+  measure: z.number(),
+});
+
+export const SpaceTokenData = tokenAliasOrValue(SpaceValue);
+
+export type SpaceUnit = z.infer<typeof SpaceUnit>;
+export type SpaceValue = z.infer<typeof SpaceValue>;
+export type SpaceTokenData = z.infer<typeof SpaceTokenData>;

package/src/dsm/elements/data/string.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const StringValue = z.string();
+export const StringTokenData = tokenAliasOrValue(StringValue);
+
+export type StringValue = z.infer<typeof StringValue>;
+export type StringTokenData = z.infer<typeof StringTokenData>;

package/src/dsm/elements/data/text-case.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const TextCase = z.enum(["Original", "Upper", "Lower", "Camel", "SmallCaps"]);
+export const TextCaseValue = TextCase;
+export const TextCaseTokenData = tokenAliasOrValue(TextCaseValue);
+
+export type TextCase = z.infer<typeof TextCase>;
+export type TextCaseValue = z.infer<typeof TextCaseValue>;
+export type TextCaseTokenData = z.infer<typeof TextCaseTokenData>;

package/src/dsm/elements/data/text-decoration.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const TextDecoration = z.enum(["None", "Underline", "Strikethrough"]);
+export const TextDecorationValue = TextDecoration;
+export const TextDecorationTokenData = tokenAliasOrValue(TextDecorationValue);
+
+export type TextDecoration = z.infer<typeof TextDecoration>;
+export type TextDecorationValue = z.infer<typeof TextDecorationValue>;
+export type TextDecorationTokenData = z.infer<typeof TextDecorationTokenData>;

package/src/dsm/elements/data/typography.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { FontSizeTokenData } from "./font-size";
+import { FontFamilyTokenData } from "./font-family";
+import { FontWeightTokenData } from "./font-weight";
+import { TextDecorationTokenData } from "./text-decoration";
+import { TextCaseTokenData } from "./text-case";
+import { LetterSpacingTokenData } from "./letter-spacing";
+import { LineHeightTokenData } from "./line-height";
+import { ParagraphIndentTokenData } from "./paragraph-indent";
+import { ParagraphSpacingTokenData } from "./paragraph-spacing";
+import { tokenAliasOrValue } from "./base";
+
+export const TypographyValue = z.object({
+  fontSize: FontSizeTokenData,
+  fontFamily: FontFamilyTokenData,
+  fontWeight: FontWeightTokenData,
+  textDecoration: TextDecorationTokenData,
+  textCase: TextCaseTokenData,
+  letterSpacing: LetterSpacingTokenData.optional(),
+  lineHeight: LineHeightTokenData.optional(),
+  paragraphIndent: ParagraphIndentTokenData.optional(),
+  paragraphSpacing: ParagraphSpacingTokenData.optional(),
+});
+
+export const TypographyTokenData = tokenAliasOrValue(TypographyValue);
+
+export type TypographyValue = z.infer<typeof TypographyValue>;
+export type TypographyTokenData = z.infer<typeof TypographyTokenData>;

package/src/dsm/elements/data/visibility.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const Visibility = z.enum(["Hidden", "Visible"]);
+export const VisibilityValue = Visibility;
+export const VisibilityTokenData = tokenAliasOrValue(VisibilityValue);
+
+export type Visibility = z.infer<typeof Visibility>;
+export type VisibilityValue = z.infer<typeof VisibilityValue>;
+export type VisibilityTokenData = z.infer<typeof VisibilityTokenData>;

package/src/dsm/elements/data/z-index.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { tokenAliasOrValue } from "./base";
+
+export const ZIndexUnit = z.enum(["Raw"]);
+
+export const ZIndexValue = z.object({
+  unit: ZIndexUnit,
+  measure: z.number(),
+});
+
+export const ZIndexTokenData = tokenAliasOrValue(ZIndexValue);
+
+export type ZIndexUnit = z.infer<typeof ZIndexUnit>;
+export type ZIndexValue = z.infer<typeof ZIndexValue>;
+export type ZIndexTokenData = z.infer<typeof ZIndexTokenData>;

package/src/dsm/elements/documentation-page-v1.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { DesignElementBase, DesignElementGroupableRequiredPart, DesignElementSlugPart } from "./base";
+import { DocumentationPageDataV1 } from "./data";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+
+export const DocumentationPageV1 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape)
+  .extend(DesignElementSlugPart.shape)
+  .extend({
+    shortPersistentId: z.string(),
+    data: DocumentationPageDataV1,
+  });
+
+export type DocumentationPageV1 = z.infer<typeof DocumentationPageV1>;
+
+export type CreateDocumentationPageV1 = DbCreateInputOmit<DocumentationPageV1>;
+export type UpdateDocumentationPageV1 = OmitStrict<DbUpdate<DocumentationPageV1>, "designSystemVersionId">;
+
+export const DocumentationPageDTOV1 = DocumentationPageV1.omit({
+  data: true,
+  meta: true,
+  parentPersistentId: true,
+  sortOrder: true,
+})
+  .extend(DocumentationPageV1.shape.data.shape)
+  .extend({
+    title: z.string(),
+    path: z.string(),
+  });
+
+export type DocumentationPageDTOV1 = z.infer<typeof DocumentationPageDTOV1>;

package/src/dsm/elements/documentation-page-v2.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { DesignElementBase, DesignElementGroupableRequiredPart, DesignElementSlugPart } from "./base";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DocumentationPageDataV2 } from "./data/documentation-page-v2";
+
+export const DocumentationPageV2 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape)
+  .extend(DesignElementSlugPart.shape)
+  .extend({
+    shortPersistentId: z.string(),
+    data: DocumentationPageDataV2,
+  });
+
+export type DocumentationPageV2 = z.infer<typeof DocumentationPageV2>;
+
+export type CreateDocumentationPageV2 = DbCreateInputOmit<DocumentationPageV2>;
+export type UpdateDocumentationPageV2 = OmitStrict<DbUpdate<DocumentationPageV2>, "designSystemVersionId">;

package/src/dsm/elements/figma-file-structures.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { DesignElementBase } from "./base";
+import { FigmaFileStructureNode, FigmaFileStructureStatistics } from "./data/figma-file-structure";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+
+export const FigmaFileStructureOrigin = z.object({
+  sourceId: z.string(),
+  fileId: z.string().optional(),
+});
+
+export const FigmaFileStructureData = z.object({
+  rootNode: FigmaFileStructureNode,
+  assetsInFile: FigmaFileStructureStatistics,
+});
+
+export const FigmaFileStructure = DesignElementBase.extend({
+  origin: FigmaFileStructureOrigin,
+  data: FigmaFileStructureData,
+});
+
+export type FigmaFileStructureOrigin = z.infer<typeof FigmaFileStructureOrigin>;
+export type FigmaFileStructureData = z.infer<typeof FigmaFileStructureData>;
+export type FigmaFileStructure = z.infer<typeof FigmaFileStructure>;
+
+export type CreateFigmaFileStructure = DbCreateInputOmit<FigmaFileStructure>;
+export type UpdateFigmaFileStructure = OmitStrict<DbUpdate<FigmaFileStructure>, "designSystemVersionId">;
+
+export type FigmaFileStructureDiff = {
+  toCreate: CreateFigmaFileStructure[];
+  toUpdate: UpdateFigmaFileStructure[];
+};
+
+export function traverseStructure(node: FigmaFileStructureNode, action: (node: FigmaFileStructureNode) => void) {
+  action(node);
+
+  for (const child of node.children) {
+    traverseStructure(child, action);
+  }
+}

package/src/dsm/elements/figma-node-reference.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { DesignElementBase } from "./base";
+import { FigmaNodeReferenceData } from "./data/figma-node-reference";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+
+export const FigmaNodeReference = DesignElementBase.extend({
+  data: FigmaNodeReferenceData,
+});
+
+export type FigmaNodeReference = z.infer<typeof FigmaNodeReference>;
+
+export type CreateFigmaNodeReference = DbCreateInputOmit<FigmaNodeReference>;
+export type UpdateFigmaNodeReference = OmitStrict<DbUpdate<FigmaNodeReference>, "designSystemVersionId">;
+
+export type FigmaNodeReferenceDiff = {
+  toUpdate: UpdateFigmaNodeReference[];
+};

package/src/dsm/elements/group.ts

@@ -0,0 +1,59 @@
+import { DesignElementType } from "./raw-element";
+import { DesignElementBase, DesignElementBrandedPart, DesignElementGroupablePart, DesignElementSlugPart } from "./base";
+import { z } from "zod";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../helpers";
+import { DocumentationGroupBehavior, ElementGroupData } from "./data";
+import { DocumentationItemConfiguration } from "./data";
+export const ElementGroup = DesignElementBase.extend(DesignElementGroupablePart.shape)
+  .extend(DesignElementSlugPart.shape)
+  .extend(DesignElementBrandedPart.partial().shape)
+  .extend({
+    shortPersistentId: z.string().optional(),
+    childType: DesignElementType,
+    data: ElementGroupData.optional(),
+  });
+
+export const BrandedElementGroup = ElementGroup.extend(DesignElementBrandedPart.shape);
+
+export type ElementGroup = z.infer<typeof ElementGroup>;
+export type BrandedElementGroup = z.infer<typeof BrandedElementGroup>;
+
+export type CreateElementGroup = OmitStrict<DbCreateInputOmit<ElementGroup>, "parentPersistentId"> & {
+  parentPersistentId: string;
+};
+
+export type UpdateElementGroup = DbUpdate<
+  OmitStrict<ElementGroup, "brandPersistentId" | "childType" | "designSystemVersionId" | "parentPersistentId"> & {
+    parentPersistentId: string;
+  }
+>;
+
+export type ElementGroupsDiff = {
+  toCreate: CreateElementGroup[];
+  toUpdate: UpdateElementGroup[];
+  toDelete: ElementGroup["id"][];
+};
+
+//
+// DTO
+//
+
+export const DocumentationGroupDTO = ElementGroup.omit({
+  sortOrder: true,
+  parentPersistentId: true,
+  brandPersistentId: true,
+  meta: true,
+  childType: true,
+  data: true,
+  shortPersistentId: true,
+}).extend({
+  title: z.string(),
+  isRoot: z.boolean(),
+  childrenIds: z.array(z.string()),
+  groupBehavior: DocumentationGroupBehavior,
+  configuration: DocumentationItemConfiguration,
+  shortPersistentId: z.string(),
+});
+
+export type DocumentationGroupDTO = z.infer<typeof DocumentationGroupDTO>;

package/src/dsm/elements/index.ts

@@ -0,0 +1,13 @@
+export * from "./data";
+export * from "./primitives";
+export * from "./base";
+export * from "./component";
+export * from "./documentation-page-v1";
+export * from "./documentation-page-v2";
+export * from "./figma-file-structures";
+export * from "./figma-node-reference";
+export * from "./group";
+export * from "./page-block-v2";
+export * from "./raw-element";
+export * from "./theme";
+export * from "./tokens";