@supernova-studio/model 0.0.4

package/src/dsm/brand.ts

@@ -0,0 +1,7 @@
+export type Brand = {
+  id: string;
+  designSystemVersionId: string;
+  persistentId: string;
+  name: string;
+  description: string;
+};

package/src/dsm/data-sources/data-source.ts

@@ -0,0 +1,158 @@
+import { z } from "zod";
+import { SourceImportSummary } from "./import-summary";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+
+//
+// Enums
+//
+
+export const DataSourceRemoteType = z.enum(["Figma", "TokenStudio", "FigmaVariablesPlugin"]);
+export const DataSourceUploadRemoteSource = z.enum(["TokenStudio", "FigmaVariablesPlugin", "Custom"]);
+export const DataSourceFigmaState = z.enum(["Active", "MissingIntegration", "MissingFileAccess", "MissingFileOwner"]);
+export const DataSourceAutoImportMode = z.enum(["Never", "Hourly"]);
+
+export type DataSourceRemoteType = z.infer<typeof DataSourceRemoteType>;
+export type DataSourceUploadRemoteSource = z.infer<typeof DataSourceUploadRemoteSource>;
+export type DataSourceFigmaState = z.infer<typeof DataSourceFigmaState>;
+export type DataSourceAutoImportMode = z.infer<typeof DataSourceAutoImportMode>;
+
+//
+// Aux
+//
+
+export const DataSourceStats = z.object({
+  tokens: zeroNumberByDefault(),
+  components: zeroNumberByDefault(),
+  assets: zeroNumberByDefault(),
+  frames: zeroNumberByDefault(),
+});
+
+export type DataSourceStats = z.infer<typeof DataSourceStats>;
+
+//
+// Figma
+//
+
+export const DataSourceFigmaFileData = z.object({
+  lastUpdatedAt: z.coerce.date(),
+});
+
+export const DataSourceFigmaFileVersionData = z.object({
+  id: z.string(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  createdAt: z.coerce.date(),
+});
+
+export const DataSourceFigmaScope = z.object({
+  assets: z.boolean(),
+  components: z.boolean(),
+  documentationFrames: z.boolean(),
+  tokens: z.boolean(),
+  themePersistentId: z.string().optional(),
+});
+
+export const DataSourceFigmaImportMetadata = z.object({
+  fileData: DataSourceFigmaFileData.optional(),
+  importedPublishedVersion: DataSourceFigmaFileVersionData.optional(),
+});
+
+export const DataSourceFigmaRemote = z.object({
+  type: z.literal(DataSourceRemoteType.Enum.Figma),
+  fileId: z.string(),
+  ownerId: z.string(),
+  ownerName: z.string(),
+  scope: DataSourceFigmaScope,
+  state: DataSourceFigmaState,
+  lastImportMetadata: DataSourceFigmaImportMetadata.optional(),
+  downloadChunkSize: z.number().optional(),
+});
+
+export type DataSourceFigmaFileData = z.infer<typeof DataSourceFigmaFileData>;
+export type DataSourceFigmaFileVersionData = z.infer<typeof DataSourceFigmaFileVersionData>;
+export type DataSourceFigmaScope = z.infer<typeof DataSourceFigmaScope>;
+export type DataSourceFigmaImportMetadata = z.infer<typeof DataSourceFigmaImportMetadata>;
+export type DataSourceFigmaRemote = z.infer<typeof DataSourceFigmaRemote>;
+
+//
+// Token Studio
+//
+
+export const DataSourceTokenStudioRemote = z.object({
+  type: z.literal(DataSourceRemoteType.Enum.TokenStudio),
+});
+
+export type DataSourceTokenStudioRemote = z.infer<typeof DataSourceTokenStudioRemote>;
+
+//
+// Figma Variables Plugin
+//
+
+export const DataSourceUploadImportMetadata = z.record(z.any());
+
+export const DataSourceUploadRemote = z.object({
+  type: z.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
+  remoteId: z.string(),
+  remoteSourceType: DataSourceUploadRemoteSource,
+  lastImportMetadata: DataSourceUploadImportMetadata.optional(),
+});
+
+export type DataSourceUploadImportMetadata = z.infer<typeof DataSourceUploadImportMetadata>;
+export type DataSourceUploadRemote = z.infer<typeof DataSourceUploadRemote>;
+
+//
+// Base
+//
+
+export const DataSourceRemote = z.discriminatedUnion("type", [
+  DataSourceFigmaRemote,
+  DataSourceUploadRemote,
+  DataSourceTokenStudioRemote,
+]);
+
+export type DataSource = {
+  id: string;
+
+  name: string;
+  thumbnailUrl: string | undefined;
+
+  // createdAt: Date;
+  // updatedAt: Date;
+
+  lastImportedAt: Date | undefined;
+  lastImportSummary: SourceImportSummary | undefined;
+
+  // lastImportJobId: Nullish<string>;
+  // lastNonEmptyImportJobId: Nullish<string>;
+
+  designSystemId: string;
+  brandPersistentId: string;
+
+  autoImportMode: DataSourceAutoImportMode;
+  stats: DataSourceStats;
+
+  remote: DataSourceRemote;
+
+  sortOrder: number;
+};
+
+export const DataSourceVersion = z.object({
+  id: z.string(),
+  createdAt: z.date(),
+  label: z.string().nullish(),
+  description: z.string().nullish(),
+});
+
+export type DataSourceVersion = z.infer<typeof DataSourceVersion>;
+
+export type DataSourceRemote = z.infer<typeof DataSourceRemote>;
+
+export type CreateDataSource = OmitStrict<DbCreateInputOmit<DataSource>, "sortOrder">;
+export type UpdateDataSource = OmitStrict<DbUpdate<DataSource>, "brandPersistentId" | "designSystemId">;
+
+function zeroNumberByDefault() {
+  return z
+    .number()
+    .nullish()
+    .transform(v => v ?? 0);
+}

package/src/dsm/data-sources/import-job.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DataSourceRemoteType } from "./data-source";
+import { Entity } from "../../common";
+
+export const ImportJobState = z.enum(["PendingInput", "Queued", "InProgress", "Failed", "Success"]);
+export const ImportJobOperation = z.enum(["Check", "Import"]);
+
+export const ImportJob = Entity.extend({
+  designSystemId: z.string(),
+  designSystemVersionId: z.string(),
+  sourceIds: z.array(z.string()),
+  state: ImportJobState,
+  createdByUserId: z.string().optional(),
+  importContextId: z.string(),
+  error: z.string().optional(),
+  sourceType: DataSourceRemoteType,
+});
+
+export type ImportJobState = z.infer<typeof ImportJobState>;
+export type ImportJobOperation = z.infer<typeof ImportJobOperation>;
+export type ImportJob = z.infer<typeof ImportJob>;
+
+export type CreateImportJob = DbCreateInputOmit<ImportJob>;
+export type UpdateImportJob = OmitStrict<
+  DbUpdate<ImportJob>,
+  "designSystemId" | "createdByUserId" | "sourceIds" | "importContextId"
+>;

package/src/dsm/data-sources/import-summary.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { DesignTokenType } from "../elements";
+import { nullishToOptional } from "../../helpers";
+import { ImportWarning } from "../import";
+
+export const FileStructureStats = z.object({
+  frames: zeroNumberByDefault(),
+  components: zeroNumberByDefault(),
+  componentSets: zeroNumberByDefault(),
+});
+
+const SourceImportSummaryByTokenTypeKey = DesignTokenType.or(
+  // Backward compatibility
+  z.enum(["Measure", "Radius", "GenericToken", "Font", "Text"])
+);
+
+export const SourceImportSummaryByTokenType = z.record(SourceImportSummaryByTokenTypeKey, z.number());
+
+export const SourceImportTokenSummary = z.object({
+  tokensCreated: zeroNumberByDefault(),
+  tokensUpdated: zeroNumberByDefault(),
+  tokensDeleted: zeroNumberByDefault(),
+  tokensCreatedPerType: SourceImportSummaryByTokenType.nullish().transform(v => v ?? {}),
+  tokensUpdatedPerType: SourceImportSummaryByTokenType.nullish().transform(v => v ?? {}),
+  tokensDeletedPerType: SourceImportSummaryByTokenType.nullish().transform(v => v ?? {}),
+});
+
+export const SourceImportComponentSummary = z.object({
+  componentsCreated: zeroNumberByDefault(),
+  componentsUpdated: zeroNumberByDefault(),
+  componentsDeleted: zeroNumberByDefault(),
+  componentAssetsCreated: zeroNumberByDefault(),
+  componentAssetsUpdated: zeroNumberByDefault(),
+  componentAssetsDeleted: zeroNumberByDefault(),
+});
+
+export const SourceImportFrameSummary = z.object({
+  assetsInFile: nullishToOptional(FileStructureStats.optional()),
+  invalidReferencesCount: nullishToOptional(z.number().optional()),
+});
+
+export const SourceImportSummary = z.object({
+  sourceId: nullishToOptional(z.string()),
+  brandId: nullishToOptional(z.string()),
+  versionId: nullishToOptional(z.string()),
+  error: nullishToOptional(z.any()),
+  isFailed: z.boolean(),
+  warnings: z
+    .array(ImportWarning)
+    .nullish()
+    .transform(v => v ?? []),
+
+  ...SourceImportTokenSummary.shape,
+  ...SourceImportComponentSummary.shape,
+  ...FileStructureStats.shape,
+});
+
+export type FileStructureStats = z.infer<typeof FileStructureStats>;
+export type SourceImportSummaryByTokenType = z.infer<typeof SourceImportSummaryByTokenType>;
+export type SourceImportTokenSummary = z.infer<typeof SourceImportTokenSummary>;
+export type SourceImportComponentSummary = z.infer<typeof SourceImportComponentSummary>;
+export type SourceImportFrameSummary = z.infer<typeof SourceImportFrameSummary>;
+export type SourceImportSummary = z.infer<typeof SourceImportSummary>;
+
+function zeroNumberByDefault() {
+  return z
+    .number()
+    .nullish()
+    .transform(v => v ?? 0);
+}

package/src/dsm/data-sources/index.ts

@@ -0,0 +1,3 @@
+export * from "./data-source";
+export * from "./import-job";
+export * from "./import-summary";

package/src/dsm/design-system.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Workspace } from "../workspace";
+export const DesignSystemSwitcher = z.object({
+  isEnabled: z.boolean(),
+  designSystemIds: z.string(),
+});
+
+export const DesignSystem = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  name: z.string(),
+  description: z.string(),
+  docExporterId: z.string().nullish(),
+  docSlug: z.string(),
+  docUserSlug: z.string().nullish(),
+  docSlugDeprecated: z.string(),
+  isPublic: z.boolean(),
+  isMultibrand: z.boolean(),
+  docViewUrl: z.string().nullish(),
+  basePrefixes: z.array(z.string()),
+  designSystemSwitcher: DesignSystemSwitcher.nullish(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const DesignSystemWithWorkspace = z.object({
+  designSystem: DesignSystem,
+  workspace: Workspace,
+});
+
+export type DesignSystemSwitcher = z.infer<typeof DesignSystemSwitcher>;
+export type DesignSystem = z.infer<typeof DesignSystem>;
+export type DesignSystemWithWorkspace = z.infer<typeof DesignSystemWithWorkspace>;

package/src/dsm/desing-system-create.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+const DS_NAME_MIN_LENGTH: number = 2;
+const DS_NAME_MAX_LENGTH: number = 64;
+const DS_DESC_MIN_LENGTH: number = 2;
+const DS_DESC_MAX_LENGTH: number = 64;
+
+const DesignSystemCreateInputMetadata = z.object({
+  name: z.string().min(DS_NAME_MIN_LENGTH).max(DS_NAME_MAX_LENGTH).trim(),
+  description: z.string().min(DS_DESC_MIN_LENGTH).max(DS_DESC_MAX_LENGTH).trim(),
+});
+
+export const DesignSystemCreateInput = z.object({
+  meta: DesignSystemCreateInputMetadata,
+  workspaceId: z.string(),
+  isPublic: z.boolean().optional(),
+  basePrefixes: z.array(z.string()).optional(),
+  docUserSlug: z.string().nullish().optional(),
+  source: z.array(z.string()).optional(),
+});
+
+export type DesignSystemCreateInput = z.infer<typeof DesignSystemCreateInput>;

package/src/dsm/desing-system-update.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+const DS_NAME_MIN_LENGTH: number = 2;
+const DS_NAME_MAX_LENGTH: number = 64;
+const DS_DESC_MIN_LENGTH: number = 2;
+const DS_DESC_MAX_LENGTH: number = 64;
+
+const DesignSystemUpdateInputMetadata = z.object({
+  name: z.string().min(DS_NAME_MIN_LENGTH).max(DS_NAME_MAX_LENGTH).trim().optional(),
+  description: z.string().min(DS_DESC_MIN_LENGTH).max(DS_DESC_MAX_LENGTH).trim().optional(),
+});
+
+export const DesignSystemUpdateInput = z.object({
+  meta: DesignSystemUpdateInputMetadata.optional(),
+  workspaceId: z.string().optional(),
+  isPublic: z.boolean().optional(),
+  basePrefixes: z.array(z.string()).optional(),
+  docUserSlug: z.string().nullish().optional(),
+  source: z.array(z.string()).optional(),
+  name: z.string().min(DS_NAME_MIN_LENGTH).max(DS_NAME_MAX_LENGTH).trim().optional(),
+  description: z.string().min(DS_DESC_MIN_LENGTH).max(DS_DESC_MAX_LENGTH).trim().optional(),
+  docExporterId: z.string().optional(),
+});
+
+export type DesignSystemUpdateInput = z.infer<typeof DesignSystemUpdateInput>;

package/src/dsm/documentation/block-definitions/aux.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const PageBlockDefinitionAppearance = z.object({
+  isBordered: z.boolean().optional(),
+  hasBackground: z.boolean().optional(),
+});
+
+export type PageBlockDefinitionAppearance = z.infer<typeof PageBlockDefinitionAppearance>;

package/src/dsm/documentation/block-definitions/definition.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { AssetValue } from "../../assets/asset-value";
+import { PageBlockDefinitionItem } from "./item";
+import { PageBlockDefinitionAppearance } from "./aux";
+
+//
+// Enums
+//
+
+export enum PageBlockCategory {
+  /** Shows as a "Text Blocks" */
+  text = "Text",
+  /** Show as "Layout blocks" */
+  layout = "Layout",
+  /** Show as "Media blocks" */
+  media = "Media",
+  /** Show as "Embed blocks" */
+  embed = "Embed",
+  /** Show as "Figma blocks" */
+  figma = "Figma",
+  /** Show as "Code blocks" */
+  code = "Code",
+  /** Show as "Guidelines blocks" */
+  guidelines = "Guidelines",
+  /** Show as "Token blocks" */
+  token = "Tokens",
+  /** Show as "Component blocks" */
+  component = "Components",
+  /** Shows as "Asset blocks" */
+  asset = "Assets",
+  /** Show as "Data blocks" */
+  data = "Data",
+  /** Shows as "Other blocks" */
+  other = "Other",
+}
+
+export enum PageBlockBehaviorDataType {
+  /** Item type uses item definition alone to construct items - examples of this are RichText, Shortcut, etc. In this mode, data panel will be hidden */
+  item = "Item",
+  /** Token type allows selection of token entity and associated groups * */
+  token = "Token",
+  /** Asset type allows selection of asset entity and associated groups * */
+  asset = "Asset",
+  /** Component type allows selection of asset entity and associated groups * */
+  component = "Component",
+}
+
+export enum PageBlockBehaviorSelectionType {
+  /** Allows selection of data entities only */
+  entity = "Entity",
+  /** Allows selection of groups only */
+  group = "Group",
+  /** Allows combined selection of data entities and groups */
+  entityAndGroup = "EntityAndGroup",
+}
+
+export const PageBlockCategorySchema = z.nativeEnum(PageBlockCategory);
+export const PageBlockBehaviorDataTypeSchema = z.nativeEnum(PageBlockBehaviorDataType);
+export const PageBlockBehaviorSelectionTypeSchema = z.nativeEnum(PageBlockBehaviorSelectionType);
+
+//
+// Definitions
+//
+
+export const PageBlockDefinitionBehavior = z.object({
+  dataType: PageBlockBehaviorDataTypeSchema,
+  items: z
+    .object({
+      numberOfItems: z.number(),
+      allowLinks: z.boolean(),
+    })
+    .optional(),
+  entities: z
+    .object({
+      selectionType: PageBlockBehaviorSelectionTypeSchema,
+      maxSelected: z.number(),
+    })
+    .optional(),
+});
+
+export const PageBlockDefinitionOnboarding = z.object({
+  helpText: z.string(),
+  documentationLink: z.string().optional(),
+});
+
+export const PageBlockDefinition = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  category: PageBlockCategorySchema,
+  icon: AssetValue.optional(),
+  documentationLink: z.string().optional(),
+  searchKeywords: z.array(z.string()).optional(),
+  item: PageBlockDefinitionItem,
+  behavior: PageBlockDefinitionBehavior,
+  editorOptions: z.object({
+    onboarding: PageBlockDefinitionOnboarding.optional(),
+  }),
+  appearance: PageBlockDefinitionAppearance.optional(),
+});
+
+export type PageBlockDefinitionBehavior = z.infer<typeof PageBlockDefinitionBehavior>;
+export type PageBlockDefinitionOnboarding = z.infer<typeof PageBlockDefinitionOnboarding>;
+export type PageBlockDefinition = z.infer<typeof PageBlockDefinition>;

package/src/dsm/documentation/block-definitions/index.ts

@@ -0,0 +1,4 @@
+export * from "./aux";
+export * from "./definition";
+export * from "./item";
+export * from "./variant";

package/src/dsm/documentation/block-definitions/item.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { PageBlockDefinitionAppearance } from "./aux";
+import { PageBlockDefinitionVariant } from "./variant";
+
+//
+// Enums
+//
+
+export enum PageBlockDefinitionPropertyType {
+  /** Rich text property allows user to input rich text (with additional attributes like bold, links etc.) */
+  richText = "RichText",
+  /** Text property allows user to input plain text */
+  text = "Text",
+  /** Boolean property allows user to input true/false value */
+  boolean = "Boolean",
+  /** Number property allows user to input number */
+  number = "Number",
+  /** Single-select property allows user to select one of the options */
+  singleSelect = "SingleSelect",
+  /** Multi-select property allows user to select multiple of the options */
+  multiSelect = "MultiSelect",
+  /** Image property allows user to select or upload image */
+  image = "Image",
+  /** Token type allows data access to the tokens defined in design system */
+  token = "Token",
+  /** Token type allows selection of type(s) such as color, typography etc., for further use such as filtering */
+  tokenType = "TokenType",
+  /** Token property allows selection of custom token properties (columns) */
+  tokenProperty = "TokenProperty",
+  /** Component type allows data access to the components defined in design system */
+  component = "Component",
+  /** Component property allows selection of custom component properties (columns) */
+  componentProperty = "ComponentProperty",
+  /** Asset type allows data access to the assets defined in design system */
+  asset = "Asset",
+  /** Asset property allows selection of custom asset properties (columns) */
+  assetProperty = "AssetProperty",
+  /** Page type allows data access to the pages defined in design system */
+  /** Page property allows selection of custom page properties (columns) */
+  /** Embed property allows user to input page to be embedded via URL */
+  embedURL = "EmbedURL",
+  /** Embed property allows user to input page to be embedded via iframe */
+  /** Markdown property allows user to add markdown to render */
+  markdown = "Markdown",
+  /** Code property allows user to add code to render */
+  code = "Code",
+  /** Sandbox property allows user to add code sandbox to render live component */
+  codeSandbox = "CodeSandbox",
+  /** Table property allows user to add table to render */
+  table = "Table",
+  /** Divider property that puts visual divider into the block. It has no user input */
+  divider = "Divider",
+  /** Storybook property allows user to add Storybook story to render */
+  storybook = "Storybook",
+}
+
+export enum PageBlockDefinitionRichTextPropertyStyle {
+  /** Title type 1, roughly equivalent of h2 in size */
+  title1 = "Title1",
+  /** Title type 2, roughly equivalent of h3 in size */
+  title2 = "Title2",
+  /** Title type 3, roughly equivalent of h4 in size */
+  title3 = "Title3",
+  /** Title type 4, roughly equivalent of h5 in size */
+  title4 = "Title4",
+  /** Title type 5, roughly equivalent of h6 in size */
+  title5 = "Title5",
+  /** Quote */
+  quote = "Quote",
+  /** Callout */
+  callout = "Callout",
+  /** Ordered list */
+  ol = "OL",
+  /** Unordered list */
+  ul = "UL",
+  /** Default option */
+  default = "Default",
+}
+
+export const PageBlockDefinitionPropertyTypeSchema = z.nativeEnum(PageBlockDefinitionPropertyType);
+export const PageBlockDefinitionRichTextPropertyStyleSchema = z.nativeEnum(PageBlockDefinitionRichTextPropertyStyle);
+
+//
+// Definitions
+//
+
+export const PageBlockDefinitionPropertyOptions = z
+  .object({
+    style: PageBlockDefinitionRichTextPropertyStyleSchema.optional(),
+    placeholder: z.string().optional(),
+  })
+  .and(z.record(z.any()));
+
+export const PageBlockDefinitionProperty = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: PageBlockDefinitionPropertyTypeSchema,
+  description: z.string().optional(),
+  // TODO Docs
+  options: PageBlockDefinitionPropertyOptions.optional(),
+  variantOptions: z.record(PageBlockDefinitionPropertyOptions).optional(),
+});
+
+export const PageBlockDefinitionItem = z.object({
+  properties: z.array(PageBlockDefinitionProperty),
+  appearance: PageBlockDefinitionAppearance.optional(),
+  variants: z.array(PageBlockDefinitionVariant),
+  defaultVariantKey: z.string(),
+});
+
+export type PageBlockDefinitionPropertyOptions = z.infer<typeof PageBlockDefinitionPropertyOptions>;
+export type PageBlockDefinitionProperty = z.infer<typeof PageBlockDefinitionProperty>;
+export type PageBlockDefinitionItem = z.infer<typeof PageBlockDefinitionItem>;

package/src/dsm/documentation/block-definitions/variant.ts

@@ -0,0 +1,78 @@
+import { ZodTypeDef, z } from "zod";
+import { PageBlockDefinitionAppearance } from "./aux";
+
+//
+// Enums
+//
+
+export enum PageBlockDefinitionLayoutType {
+  /** Layout will stack all its items in this group into column */
+  column = "Column",
+  /** Layout will stack all its items in this group into row */
+  row = "Row",
+}
+
+export enum PageBlockDefinitionLayoutGap {
+  /** small gap between columns/row */
+  small = "Small",
+  /** medium gap between columns/row */
+  medium = "Medium",
+  /** large gap between columns/row */
+  large = "Large",
+  /** no gap between columns/row */
+  none = "None",
+}
+
+export enum PageBlockDefinitionLayoutAlign {
+  /** Vertically on top */
+  start = "Start",
+  /** Vertically centered */
+  center = "Center",
+  /** Vertically on the bottom */
+  end = "End",
+}
+
+export enum PageBlockDefinitionLayoutResizing {
+  /** Will fill all available space for the column */
+  fill = "Fill",
+  /** Will hug content inside the column */
+  hug = "Hug",
+}
+
+export const PageBlockDefinitionLayoutTypeSchema = z.nativeEnum(PageBlockDefinitionLayoutType);
+export const PageBlockDefinitionLayoutGapSchema = z.nativeEnum(PageBlockDefinitionLayoutGap);
+export const PageBlockDefinitionLayoutAlignSchema = z.nativeEnum(PageBlockDefinitionLayoutAlign);
+export const PageBlockDefinitionLayoutResizingSchema = z.nativeEnum(PageBlockDefinitionLayoutResizing);
+
+//
+// Definitions
+//
+
+export const PageBlockDefinitionLayoutBase = z.object({
+  type: PageBlockDefinitionLayoutTypeSchema,
+  gap: PageBlockDefinitionLayoutGapSchema.optional(),
+  columnAlign: PageBlockDefinitionLayoutAlignSchema.optional(),
+  columnResizing: PageBlockDefinitionLayoutResizingSchema.optional(),
+});
+
+export const PageBlockDefinitionLayout: z.ZodType<PageBlockDefinitionLayout, ZodTypeDef, PageBlockDefinitionLayout> =
+  PageBlockDefinitionLayoutBase.extend({
+    children: z.lazy(() => z.array(PageBlockDefinitionLayout.or(z.string()))),
+  });
+
+export const PageBlockDefinitionVariant = z.object({
+  id: z.string(),
+  name: z.string(),
+  image: z.string().optional(),
+  description: z.string().optional(),
+  documentationLink: z.string().optional(),
+  layout: PageBlockDefinitionLayout,
+  maxColumns: z.number().optional(),
+  defaultColumns: z.number().optional(),
+  appearance: PageBlockDefinitionAppearance.optional(),
+});
+
+export type PageBlockDefinitionVariant = z.infer<typeof PageBlockDefinitionVariant>;
+export type PageBlockDefinitionLayout = z.infer<typeof PageBlockDefinitionLayoutBase> & {
+  children: (PageBlockDefinitionLayout | string)[];
+};

package/src/dsm/documentation/group.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+export const DocumentationPageGroup = z.object({
+  type: z.literal("ElementGroup"),
+  childType: z.literal("DocumentationPage"),
+  id: z.string(),
+  persistentId: z.string(),
+  shortPersistentId: z.string(),
+  designSystemVersionId: z.string(),
+  parentPersistentId: z.string().nullish(),
+  sortOrder: z.number(),
+  title: z.string(),
+  slug: z.string(),
+  userSlug: z.string().nullish(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export type DocumentationPageGroup = z.infer<typeof DocumentationPageGroup>;