@supernova-studio/client 1.96.5 → 1.96.7

package/src/api/dto/design-systems/figma-variables.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+
+const DimensionsVariableScopeSchema = z.enum([
+  "CORNER_RADIUS",
+  "WIDTH_HEIGHT",
+  "GAP",
+  "STROKE_FLOAT",
+  "EFFECT_FLOAT",
+  "OPACITY",
+  "FONT_SIZE",
+  "LINE_HEIGHT",
+  "LETTER_SPACING",
+  "PARAGRAPH_SPACING",
+  "PARAGRAPH_INDENT",
+  "FONT_WEIGHT",
+]);
+
+const StringVariableScopeSchema = z.enum(["TEXT_CONTENT", "FONT_FAMILY", "FONT_STYLE"]);
+
+export type DimensionsVariableScopeType = z.infer<typeof DimensionsVariableScopeSchema>;
+export const DimensionsVariableScopeType = DimensionsVariableScopeSchema.enum;
+
+export type StringVariableScopeType = z.infer<typeof StringVariableScopeSchema>;
+export const StringVariableScopeType = StringVariableScopeSchema.enum;
+
+const VariableScope = z.string();
+
+const ReferencedVariableOrigin = z.object({
+  name: z.string(),
+  remote: z.boolean(),
+});
+
+export const RGB = z.object({
+  r: z.number(),
+  g: z.number(),
+  b: z.number(),
+});
+
+export const RGBA = RGB.extend({
+  a: z.number(),
+});
+
+export const VariableAlias = z.object({
+  type: z.literal("VARIABLE_ALIAS"),
+  id: z.string(),
+  resolvedValue: z.boolean().or(z.number()).or(z.string()).or(RGBA).or(RGB).optional(),
+  referenceOrigin: ReferencedVariableOrigin.optional().or(z.null()),
+});
+
+export const VariableValue = z.boolean().or(z.number()).or(z.string()).or(RGBA).or(RGB).or(VariableAlias);
+export const ResolvedVariableType = z.enum(["BOOLEAN", "FLOAT", "STRING", "COLOR"]);
+
+export const Variable = z.object({
+  id: z.string(),
+  name: z.string(),
+  key: z.string(),
+  variableCollectionId: z.string(),
+  variableCollectionKey: z.string(),
+  resolvedType: ResolvedVariableType,
+  valuesByMode: z.record(VariableValue),
+  remote: z.boolean(),
+  description: z.string(),
+  hiddenFromPublishing: z.boolean(),
+  scopes: z.array(VariableScope),
+  codeSyntax: z.record(z.any()).optional(),
+});
+
+export const VariableMode = z.object({
+  modeId: z.string(),
+  name: z.string(),
+  parentModeId: z.string().optional(),
+});
+
+export const Collection = z.object({
+  id: z.string(),
+  name: z.string(),
+  key: z.string(),
+  modes: z.array(VariableMode),
+  defaultModeId: z.string(),
+  remote: z.boolean(),
+  hiddenFromPublishing: z.boolean(),
+
+  isExtension: z.boolean().optional(),
+  parentVariableCollectionId: z.string().optional(),
+  parentVariableCollectionKey: z.string().optional(),
+  variableOverrides: z.record(z.string(), z.record(z.string(), VariableValue)).optional(),
+});
+
+export const VariablesMapping = z.object({
+  variableCollections: z.array(z.string()).min(1),
+  variableCollectionKeys: z.array(z.string()),
+  variableMode: z.string().min(1),
+  supernovaBrand: z.string().min(1),
+  supernovaTheme: z.string().min(1).nullable().optional(),
+});
+
+export const VariableCollectionsSchema = z.record(z.string(), Collection);
+export const VariablesSchema = z.record(z.string(), Variable);
+
+export const FormattedCollections = z.object({
+  variableCollections: VariableCollectionsSchema,
+  variables: VariablesSchema,
+  variablesOrder: z.string().array().optional(),
+  mappings: z.array(VariablesMapping).optional(),
+});
+
+//
+// Types
+//
+
+export type RGB = z.infer<typeof RGB>;
+export type RGBA = z.infer<typeof RGBA>;
+export type ResolvedVariableType = z.infer<typeof ResolvedVariableType>;
+export type Variable = z.infer<typeof Variable>;
+export type VariableAlias = z.infer<typeof VariableAlias>;
+export type VariableValue = z.infer<typeof VariableValue>;
+export type VariableMode = z.infer<typeof VariableMode>;
+export type Collection = z.infer<typeof Collection>;
+export type VariablesMapping = z.infer<typeof VariablesMapping>;
+export type VariableCollections = z.infer<typeof VariableCollectionsSchema>;
+export type Variables = z.infer<typeof VariablesSchema>;
+export type FormattedCollections = z.infer<typeof FormattedCollections>;

package/src/api/dto/design-systems/file.ts

@@ -0,0 +1,71 @@
+import { AssetScope } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOAssetScope = AssetScope;
+
+export const DTOFileUploadItem = z.object({
+  size: z.number(),
+  name: z.string(),
+  checksum: z.string(),
+  scope: DTOAssetScope.exclude(["ComponentThumbnail", "DocumentationFrame"]).optional(),
+});
+
+export const DTOFileUploadPayload = z.object({
+  files: z.array(DTOFileUploadItem),
+});
+
+export const DTOFileUploadResponseItem = z.object({
+  fileId: z.string(),
+  referencePersistentId: z.string(),
+  name: z.string(),
+  checksum: z.string(),
+  pendingUpload: z.boolean().optional(),
+  url: z.string(),
+  size: z.number(),
+});
+
+export const DTOFileResponseItem = DTOFileUploadResponseItem;
+
+export const DTOUploadUrlItem = z.object({
+  fileId: z.string(),
+  uploadUrl: z.string(),
+});
+
+export const DTOFileUploadResponse = z.object({
+  files: z.array(DTOFileUploadResponseItem),
+  uploadUrls: z.array(DTOUploadUrlItem),
+});
+
+/**
+ * @deprecated Use GET method with DTOFilesGetQuery
+ */
+export const DTOFilesGetPayload = z.object({
+  persistentIds: z.string().array().optional(),
+});
+
+export const DTOFilesGetQuery = z.object({
+  includeScope: DTOAssetScope.optional(),
+});
+
+export const DTOFilesResponse = z.object({
+  files: z.array(DTOFileResponseItem),
+});
+
+export const DTOFileUploadFinalizePayload = z.object({
+  fileIds: z.array(z.string()),
+});
+
+export const DTOFileUploadFinalizeResponse = z.object({ ok: z.literal(true) });
+
+export type DTOFileUploadItem = z.infer<typeof DTOFileUploadItem>;
+export type DTOFileUploadPayload = z.infer<typeof DTOFileUploadPayload>;
+export type DTOFileUploadResponseItem = z.infer<typeof DTOFileUploadResponseItem>;
+export type DTOUploadUrlItem = z.infer<typeof DTOUploadUrlItem>;
+export type DTOFileUploadResponse = z.infer<typeof DTOFileUploadResponse>;
+export type DTOFileUploadFinalizePayload = z.infer<typeof DTOFileUploadFinalizePayload>;
+export type DTOFileUploadFinalizeResponse = z.infer<typeof DTOFileUploadFinalizeResponse>;
+export type DTOFileResponseItem = z.infer<typeof DTOFileResponseItem>;
+export type DTOFilesGetPayload = z.infer<typeof DTOFilesGetPayload>;
+export type DTOFilesResponse = z.infer<typeof DTOFilesResponse>;
+export type DTOFilesGetQuery = z.infer<typeof DTOFilesGetQuery>;
+export type DTOAssetScope = z.infer<typeof DTOAssetScope>;

package/src/api/dto/design-systems/import-job.ts

@@ -0,0 +1,62 @@
+import {
+  DataSourceAutoImportMode,
+  DataSourceFigmaScope,
+  DataSourceRemoteType,
+  ImportJobState,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTOImportJob = z.object({
+  id: z.string(),
+  designSystemId: z.string(),
+  designSystemVersionId: z.string(),
+  operation: z.literal("Import"),
+  createdAt: z.coerce.date(),
+  stateChangedAt: z.coerce.date(),
+  state: ImportJobState,
+  sourceIds: z.string().array(),
+});
+
+export const DTOImportJobResponse = z.object({
+  job: DTOImportJob,
+});
+
+export type DTOImportJob = z.infer<typeof DTOImportJob>;
+export type DTOImportJobResponse = z.infer<typeof DTOImportJobResponse>;
+
+//
+// Write
+//
+
+export const DTOBffFigmaImportRequestBody = z.object({
+  type: z.literal(DataSourceRemoteType.Enum.Figma),
+  brandPersistentId: z.string().optional(),
+  fileId: z.string(),
+  scope: DataSourceFigmaScope,
+  autoImportMode: DataSourceAutoImportMode,
+});
+
+export const DTOBffUploadImportRequestBody = z.object({
+  type: z
+    .enum([DataSourceRemoteType.Enum.FigmaVariablesPlugin, "Upload"])
+    .transform(v => DataSourceRemoteType.Enum.FigmaVariablesPlugin),
+  brandPersistentId: z.string().optional(),
+  sourceName: z.string().optional(),
+  remoteId: z.string(),
+  isTokenTypeSplitEnabled: z.boolean().optional(),
+  version: z.string().optional(),
+  payload: z.any(),
+});
+
+export const DTOBffImportRequestBody = z.discriminatedUnion("type", [
+  DTOBffFigmaImportRequestBody,
+  DTOBffUploadImportRequestBody,
+]);
+
+export type DTOBffFigmaImportRequestBody = z.infer<typeof DTOBffFigmaImportRequestBody>;
+export type DTOBffUploadImportRequestBody = z.infer<typeof DTOBffUploadImportRequestBody>;
+export type DTOBffImportRequestBody = z.infer<typeof DTOBffImportRequestBody>;

package/src/api/dto/design-systems/index.ts

@@ -0,0 +1,24 @@
+export * from "./brand";
+export * from "./code-component-usage";
+export * from "./code-component";
+export * from "./code-history";
+export * from "./code-scan";
+export * from "./code-snapshots";
+export * from "./component";
+export * from "./contact";
+export * from "./data-source";
+export * from "./design-system";
+export * from "./documentation-search";
+export * from "./elements-diff";
+export * from "./figma-variables";
+export * from "./file";
+export * from "./import-job";
+export * from "./members";
+export * from "./redirects";
+export * from "./role";
+export * from "./stats";
+export * from "./storybook";
+export * from "./user-design-systems";
+export * from "./version-room";
+export * from "./version";
+export * from "./view";

package/src/api/dto/design-systems/members.ts

@@ -0,0 +1,52 @@
+import { DesignSystemMembershipUpdates } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTODesignSystemRole } from "./role";
+
+//
+// Read
+//
+
+export const DTODesignSystemMember = z.object({
+  userId: z.string(),
+
+  /**
+   * Role that the member has in the design system,
+   * undefined if set to inherit from workspace
+   */
+  designSystemRole: DTODesignSystemRole.optional(),
+
+  isDeactivated: z.boolean(),
+});
+
+export const DTODesignSystemInvitation = z.object({
+  id: z.string(),
+  workspaceInvitationId: z.string(),
+
+  /**
+   * Role that the invitation has in the design system,
+   * undefined if set to inherit from workspace
+   */
+  designSystemRole: DTODesignSystemRole.optional(),
+});
+
+export const DTODesignSystemMemberListResponse = z.object({
+  members: DTODesignSystemMember.array(),
+  invitations: DTODesignSystemInvitation.array(),
+});
+
+export const DTODesignSystemMembersUpdateResponse = z.object({
+  ok: z.literal(true),
+});
+
+export type DTODesignSystemMember = z.infer<typeof DTODesignSystemMember>;
+export type DTODesignSystemInvitation = z.infer<typeof DTODesignSystemInvitation>;
+export type DTODesignSystemMemberListResponse = z.infer<typeof DTODesignSystemMemberListResponse>;
+export type DTODesignSystemMembersUpdateResponse = z.infer<typeof DTODesignSystemMembersUpdateResponse>;
+
+//
+// Write
+//
+
+export const DTODesignSystemMembersUpdatePayload = DesignSystemMembershipUpdates;
+
+export type DTODesignSystemMembersUpdatePayload = z.infer<typeof DTODesignSystemMembersUpdatePayload>;

package/src/api/dto/design-systems/redirects.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+
+export const DTOPageRedirectCreateBody = z.object({
+  pagePersistentId: z.string(),
+  path: z.string(),
+});
+
+export const DTOPageRedirectUpdateBody = DTOPageRedirectCreateBody.partial();
+
+export const DTOPageRedirect = z.object({
+  id: z.string(),
+  pagePersistentId: z.string(),
+  path: z.string(),
+});
+
+export const DTOPageRedirectListResponse = z.object({
+  redirects: DTOPageRedirect.array(),
+});
+
+export const DTOPageRedirectResponse = z.object({
+  redirect: DTOPageRedirect,
+});
+
+export const DTOPageRedirectDeleteResponse = z.object({
+  success: z.boolean(),
+});
+
+export type DTOPageRedirectCreateBody = z.infer<typeof DTOPageRedirectCreateBody>;
+export type DTOPageRedirectUpdateBody = z.infer<typeof DTOPageRedirectUpdateBody>;
+export type DTOPageRedirect = z.infer<typeof DTOPageRedirect>;
+export type DTOPageRedirectListResponse = z.infer<typeof DTOPageRedirectListResponse>;
+export type DTOPageRedirectResponse = z.infer<typeof DTOPageRedirectResponse>;
+export type DTOPageRedirectDeleteResponse = z.infer<typeof DTOPageRedirectDeleteResponse>;

package/src/api/dto/design-systems/role.ts

@@ -0,0 +1,11 @@
+import { WorkspaceRole } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTODesignSystemRole = z.enum([
+  WorkspaceRole.Admin,
+  WorkspaceRole.Contributor,
+  WorkspaceRole.Creator,
+  WorkspaceRole.Viewer,
+]);
+
+export type DTODesignSystemRole = z.infer<typeof DTODesignSystemRole>;

package/src/api/dto/design-systems/stats.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+export const DTODesignSystemVersionStats = z.object({
+  tokens: z.number(),
+  designSystemComponents: z.number(),
+  assets: z.number(),
+  documentationPages: z.number(),
+  figmaComponents: z.number(),
+  stories: z.number(),
+});
+
+export const DTODesignSystemVersionStatsQuery = z.object({
+  /**
+   * Unique ID across versions (non-persistent ID)
+   */
+  brandId: z.string().optional(),
+});
+
+export type DTODesignSystemVersionStats = z.infer<typeof DTODesignSystemVersionStats>;
+export type DTODesignSystemVersionStatsQuery = z.infer<typeof DTODesignSystemVersionStatsQuery>;

package/src/api/dto/design-systems/storybook.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { zodQueryBoolean } from "../../../utils/query";
+
+export const DTOStorybookEntryOrigin = z.object({
+  id: z.string(),
+  type: z.enum(["story", "docs"]),
+  name: z.string(),
+  title: z.string(),
+});
+
+export const DTOStorybookEntry = z.object({
+  id: z.string(),
+  storyId: z.string(),
+  designSystemId: z.string(),
+  sourceId: z.string(),
+  aliases: z.array(z.string()).optional(),
+  url: z.string(),
+  isDeleted: z.boolean().optional(),
+  origin: DTOStorybookEntryOrigin,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const DTOStorybookEntryReplaceAction = z.object({
+  newStoryId: z.string(),
+});
+
+export const DTOStorybookEntryQuery = z.object({
+  /**
+   * Unique ID across versions (non-persistent ID)
+   */
+  brandId: z.string().optional(),
+
+  excludeDocs: zodQueryBoolean(),
+});
+
+export const DTOStorybookEntryListResponse = z.object({ entries: z.array(DTOStorybookEntry) });
+export const DTOStorybookEntryResponse = z.object({ entry: DTOStorybookEntry });
+
+export type DTOStorybookEntryQuery = z.infer<typeof DTOStorybookEntryQuery>;
+export type DTOStorybookEntry = z.infer<typeof DTOStorybookEntry>;
+export type DTOStorybookEntryOrigin = z.infer<typeof DTOStorybookEntryOrigin>;
+export type DTOStorybookEntryReplaceAction = z.infer<typeof DTOStorybookEntryReplaceAction>;
+export type DTOStorybookEntryListResponse = z.infer<typeof DTOStorybookEntryListResponse>;
+export type DTOStorybookEntryResponse = z.infer<typeof DTOStorybookEntryResponse>;

package/src/api/dto/design-systems/user-design-systems.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { DTODesignSystem } from "./design-system";
+import { DTOWorkspace } from "../workspaces";
+
+export const DTOUserDesignSystemsResponse = z.object({
+  designSystems: DTODesignSystem.array(),
+  workspaces: DTOWorkspace.array(),
+});
+
+export type DTOUserDesignSystemsResponse = z.infer<typeof DTOUserDesignSystemsResponse>;

package/src/api/dto/design-systems/version-room.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const DTODesignSystemVersionRoom = z.object({
+  id: z.string(),
+});
+
+export const DTODesignSystemVersionRoomResponse = z.object({
+  room: DTODesignSystemVersionRoom,
+});
+
+export type DTODesignSystemVersionRoom = z.infer<typeof DTODesignSystemVersionRoom>;
+export type DTODesignSystemVersionRoomResponse = z.infer<typeof DTODesignSystemVersionRoomResponse>;

package/src/api/dto/design-systems/version.ts

@@ -0,0 +1,56 @@
+import { ObjectMeta, VersionCreationJob } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOCreateVersionInput } from "../../payloads";
+
+export const DTODesignSystemVersion = z.object({
+  id: z.string(),
+  createdAt: z.coerce.date(),
+  meta: ObjectMeta,
+  version: z.string(),
+  isReadonly: z.boolean(),
+  changeLog: z.string(),
+  designSystemId: z.string(),
+});
+
+export const DTODesignSystemVersionsListResponse = z.object({
+  designSystemVersions: z.array(DTODesignSystemVersion),
+});
+
+export const DTODesignSystemVersionGetResponse = z.object({
+  designSystemVersion: DTODesignSystemVersion,
+});
+
+export const DTODesignSystemVersionCreationResponse = z.object({
+  meta: ObjectMeta,
+  version: z.string(),
+  changeLog: z.string(),
+  isReadOnly: z.boolean(),
+  designSystemId: z.string(),
+  jobId: z.string(),
+});
+
+export const VersionSQSPayload = z.object({
+  jobId: z.string(),
+  designSystemId: z.string(),
+  input: DTOCreateVersionInput,
+});
+
+export type VersionSQSPayload = z.infer<typeof VersionSQSPayload>;
+
+export type DTODesignSystemVersionCreationResponse = z.infer<typeof DTODesignSystemVersionCreationResponse>;
+export type DTODesignSystemVersion = z.infer<typeof DTODesignSystemVersion>;
+export type DTODesignSystemVersionsListResponse = z.infer<typeof DTODesignSystemVersionsListResponse>;
+export type DTODesignSystemVersionGetResponse = z.infer<typeof DTODesignSystemVersionGetResponse>;
+
+export const DTODesignSystemVersionJobsResponse = z.object({
+  jobs: z.array(VersionCreationJob),
+});
+
+export type DTODesignSystemVersionJobsResponse = z.infer<typeof DTODesignSystemVersionJobsResponse>;
+
+// Creation job status response
+export const DTODesignSystemVersionJobStatusResponse = z.object({
+  job: VersionCreationJob,
+});
+
+export type DTODesignSystemVersionJobStatusResponse = z.infer<typeof DTODesignSystemVersionJobStatusResponse>;

package/src/api/dto/design-systems/view.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { ElementPropertyTargetType, ElementViewBaseColumnType, ObjectMeta } from "@supernova-studio/model";
+
+export const DTOElementViewColumnSharedAttributes = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  width: z.number(),
+});
+
+export const DTOElementViewBasePropertyColumn = DTOElementViewColumnSharedAttributes.extend({
+  type: z.literal("BaseProperty"),
+  basePropertyType: ElementViewBaseColumnType,
+});
+
+export const DTOElementViewPropertyDefinitionColumn = DTOElementViewColumnSharedAttributes.extend({
+  type: z.literal("PropertyDefinition"),
+  propertyDefinitionId: z.string(),
+});
+
+export const DTOElementViewThemeColumn = DTOElementViewColumnSharedAttributes.extend({
+  type: z.literal("Theme"),
+  themeId: z.string(),
+});
+
+export const DTOElementViewColumn = z.discriminatedUnion("type", [
+  DTOElementViewBasePropertyColumn,
+  DTOElementViewPropertyDefinitionColumn,
+  DTOElementViewThemeColumn,
+]);
+
+export const DTOElementView = z.object({
+  meta: ObjectMeta,
+  persistentId: z.string(),
+  targetElementType: ElementPropertyTargetType,
+  id: z.string(),
+  isDefault: z.boolean(),
+  columns: z.array(DTOElementViewColumn),
+});
+
+export const DTOElementViewsListResponse = z.object({
+  elementDataViews: z.array(DTOElementView),
+});
+
+export type DTOElementView = z.infer<typeof DTOElementView>;
+export type DTOElementViewsListResponse = z.infer<typeof DTOElementViewsListResponse>;

package/src/api/dto/design-tokens/design-token.ts

@@ -0,0 +1,78 @@
+import { DesignTokenOrigin, DesignTokenType, DesignTokenTypedData, ObjectMeta } from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTODesignToken = DesignTokenTypedData.and(
+  z.object({
+    id: z.string(),
+    persistentId: z.string(),
+    designSystemVersionId: z.string(),
+    meta: ObjectMeta,
+    originStyle: DesignTokenOrigin.optional(),
+    brandId: z.string(),
+    collectionId: z.string().optional(),
+    updatedAt: z.coerce.date(),
+  })
+);
+
+export const DTODesignTokenListResponse = z.object({
+  tokens: DTODesignToken.array(),
+});
+
+export const DTODesignTokenResponse = z.object({
+  token: DTODesignToken,
+});
+
+export const DTODesignTokenGroup = z.object({
+  id: z.string(),
+  tokenType: DesignTokenType,
+  persistentId: z.string(),
+  isRoot: z.boolean(),
+  brandId: z.string(),
+  meta: ObjectMeta,
+  childrenIds: z.string().array(),
+});
+
+export const DTODesignTokenGroupListResponse = z.object({
+  groups: DTODesignTokenGroup.array(),
+});
+
+export const DTODesignTokenGroupResponse = z.object({
+  group: DTODesignTokenGroup,
+});
+
+export type DTODesignToken = z.infer<typeof DTODesignToken>;
+export type DTODesignTokenResponse = z.infer<typeof DTODesignTokenResponse>;
+export type DTODesignTokenListResponse = z.infer<typeof DTODesignTokenListResponse>;
+
+export type DTODesignTokenGroup = z.infer<typeof DTODesignTokenGroup>;
+export type DTODesignTokenGroupListResponse = z.infer<typeof DTODesignTokenGroupListResponse>;
+export type DTODesignTokenGroupResponse = z.infer<typeof DTODesignTokenGroupResponse>;
+
+//
+// Write
+//
+
+export const DTODesignTokenCreatePayload = DesignTokenTypedData.and(
+  z.object({
+    persistentId: z.string(),
+    meta: ObjectMeta,
+    brandId: z.string(),
+    groupPersistentId: z.string().optional(),
+  })
+);
+
+export const DTODesignTokenGroupCreatePayload = z.object({
+  persistentId: z.string(),
+  meta: ObjectMeta,
+  brandId: z.string(),
+  parentId: z.string().optional(),
+  tokenType: DesignTokenType,
+  childrenIds: z.string().array(),
+});
+
+export type DTODesignTokenCreatePayload = z.infer<typeof DTODesignTokenCreatePayload>;
+export type DTODesignTokenGroupCreatePayload = z.infer<typeof DTODesignTokenGroupCreatePayload>;

package/src/api/dto/design-tokens/index.ts

@@ -0,0 +1 @@
+export * from "./design-token";