@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/elements/elements-action-v2.ts

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import {
+  DTODocumentationGroupCreateActionInputV2,
+  DTODocumentationGroupCreateActionOutputV2,
+  DTODocumentationGroupDeleteActionInputV2,
+  DTODocumentationGroupDeleteActionOutputV2,
+  DTODocumentationGroupDuplicateActionInputV2,
+  DTODocumentationGroupDuplicateActionOutputV2,
+  DTODocumentationGroupMoveActionInputV2,
+  DTODocumentationGroupMoveActionOutputV2,
+  DTODocumentationGroupUpdateActionInputV2,
+  DTODocumentationGroupUpdateActionOutputV2,
+  DTODocumentationTabCreateActionInputV2,
+  DTODocumentationTabCreateActionOutputV2,
+  DTODocumentationTabGroupDeleteActionInputV2,
+  DTODocumentationTabGroupDeleteActionOutputV2,
+} from "./documentation/group-action";
+import {
+  DTODocumentationGroupRestoreActionInput,
+  DTODocumentationGroupRestoreActionOutput,
+  DTODocumentationPageApprovalStateChangeActionInput,
+  DTODocumentationPageApprovalStateChangeActionOutput,
+  DTODocumentationPageCreateActionInputV2,
+  DTODocumentationPageCreateActionOutputV2,
+  DTODocumentationPageDeleteActionInputV2,
+  DTODocumentationPageDeleteActionOutputV2,
+  DTODocumentationPageDuplicateActionInputV2,
+  DTODocumentationPageDuplicateActionOutputV2,
+  DTODocumentationPageMoveActionInputV2,
+  DTODocumentationPageMoveActionOutputV2,
+  DTODocumentationPageRestoreActionInput,
+  DTODocumentationPageRestoreActionOutput,
+  DTODocumentationPageUpdateActionInputV2,
+  DTODocumentationPageUpdateActionOutputV2,
+  DTODocumentationPageUpdateDocumentActionInputV2,
+  DTODocumentationPageUpdateDocumentActionOutputV2,
+} from "./documentation/page-actions-v2";
+import { DTOFigmaNodeRenderAsyncActionInput, DTOFigmaNodeRenderAsyncActionOutput } from "./figma-nodes/node-actions-v2";
+import { DTOElementPropertyValuesEditActionInput, DTOElementPropertyValuesEditActionOutput } from "./properties";
+
+//
+// Read
+//
+
+export const DTOElementActionOutput = z.discriminatedUnion("type", [
+  // Documentation pages
+  DTODocumentationPageCreateActionOutputV2,
+  DTODocumentationPageUpdateActionOutputV2,
+  DTODocumentationPageUpdateDocumentActionOutputV2,
+  DTODocumentationPageMoveActionOutputV2,
+  DTODocumentationPageDuplicateActionOutputV2,
+  DTODocumentationPageDeleteActionOutputV2,
+
+  // Documentation groups
+  DTODocumentationGroupCreateActionOutputV2,
+  DTODocumentationTabCreateActionOutputV2,
+  DTODocumentationGroupUpdateActionOutputV2,
+  DTODocumentationGroupMoveActionOutputV2,
+  DTODocumentationGroupDuplicateActionOutputV2,
+  DTODocumentationGroupDeleteActionOutputV2,
+  DTODocumentationTabGroupDeleteActionOutputV2,
+
+  // Figma frames
+  DTOFigmaNodeRenderAsyncActionOutput,
+
+  // Restore
+  DTODocumentationPageRestoreActionOutput,
+  DTODocumentationGroupRestoreActionOutput,
+
+  // Approvals
+  DTODocumentationPageApprovalStateChangeActionOutput,
+
+  // Element properties
+  DTOElementPropertyValuesEditActionOutput,
+]);
+
+export type DTOElementActionOutput = z.infer<typeof DTOElementActionOutput>;
+
+//
+// Write
+//
+
+export const DTOElementActionInput = z
+  .discriminatedUnion("type", [
+    // Documentation pages
+    DTODocumentationPageCreateActionInputV2,
+    DTODocumentationPageUpdateActionInputV2,
+    DTODocumentationPageUpdateDocumentActionInputV2,
+    DTODocumentationPageMoveActionInputV2,
+    DTODocumentationPageDuplicateActionInputV2,
+    DTODocumentationPageDeleteActionInputV2,
+
+    // Documentation groups
+    DTODocumentationGroupCreateActionInputV2,
+    DTODocumentationTabCreateActionInputV2,
+    DTODocumentationGroupUpdateActionInputV2,
+    DTODocumentationGroupMoveActionInputV2,
+    DTODocumentationGroupDuplicateActionInputV2,
+    DTODocumentationGroupDeleteActionInputV2,
+    DTODocumentationTabGroupDeleteActionInputV2,
+
+    // Figma frames
+    DTOFigmaNodeRenderAsyncActionInput,
+
+    // Restore
+    DTODocumentationPageRestoreActionInput,
+    DTODocumentationGroupRestoreActionInput,
+
+    // Approval
+    DTODocumentationPageApprovalStateChangeActionInput,
+
+    // Element properties
+    DTOElementPropertyValuesEditActionInput,
+  ])
+  .and(
+    z.object({
+      tId: z.string().optional(),
+    })
+  );
+
+export type DTOElementActionInput = z.infer<typeof DTOElementActionInput>;
+export type DTOElementActionInputOfType<T extends DTOElementActionInput["type"]> = Extract<
+  DTOElementActionInput,
+  { type: T }
+>;

package/src/api/dto/elements/figma-nodes/figma-node-structure.ts

@@ -0,0 +1,27 @@
+import { FigmaFileStructureNode, FigmaNodeStructureStateV2 } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOFigmaNodeStructure = z.object({
+  id: z.string(),
+  sourceId: z.string(),
+  importState: FigmaNodeStructureStateV2,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const DTOFigmaNodeStructureDetail = DTOFigmaNodeStructure.extend({
+  rootNode: FigmaFileStructureNode,
+});
+
+export const DTOFigmaNodeStructureListResponse = z.object({
+  structures: DTOFigmaNodeStructure.array(),
+});
+
+export const DTOFigmaNodeStructureDetailResponse = z.object({
+  structure: DTOFigmaNodeStructureDetail,
+});
+
+export type DTOFigmaNodeStructure = z.infer<typeof DTOFigmaNodeStructure>;
+export type DTOFigmaNodeStructureDetail = z.infer<typeof DTOFigmaNodeStructureDetail>;
+export type DTOFigmaNodeStructureListResponse = z.infer<typeof DTOFigmaNodeStructureListResponse>;
+export type DTOFigmaNodeStructureDetailResponse = z.infer<typeof DTOFigmaNodeStructureDetailResponse>;

package/src/api/dto/elements/figma-nodes/figma-node-v1.ts

@@ -0,0 +1,32 @@
+import { FigmaNodeReference } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOFigmaNodeOrigin, DTOFigmaNodeRenderFormat } from "./figma-node";
+
+export const DTOFigmaNodeData = z.object({
+  // Id of the node in the Figma file
+  figmaNodeId: z.string(),
+
+  // Validity
+  isValid: z.boolean(),
+
+  // Asset data
+  assetId: z.string(),
+  assetUrl: z.string(),
+  assetFormat: DTOFigmaNodeRenderFormat,
+
+  // Asset metadata
+  assetScale: z.number(),
+  assetWidth: z.number().optional(),
+  assetHeight: z.number().optional(),
+});
+
+export const DTOFigmaNode = FigmaNodeReference.omit({
+  data: true,
+  origin: true,
+}).extend({
+  data: DTOFigmaNodeData,
+  origin: DTOFigmaNodeOrigin,
+});
+
+export type DTOFigmaNodeData = z.infer<typeof DTOFigmaNodeData>;
+export type DTOFigmaNode = z.infer<typeof DTOFigmaNode>;

package/src/api/dto/elements/figma-nodes/figma-node-v2.ts

@@ -0,0 +1,32 @@
+import {
+  FigmaNodeReference,
+  FigmaNodeRenderedImage,
+  FigmaNodeRenderError,
+  FigmaNodeRenderFormat,
+  FigmaNodeRenderState,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOFigmaNodeOrigin } from "./figma-node";
+
+export const DTOFigmaNodeDataV2 = z.object({
+  sceneNodeId: z.string(),
+  format: FigmaNodeRenderFormat,
+  scale: z.number().optional(),
+
+  renderState: FigmaNodeRenderState,
+  renderedImage: FigmaNodeRenderedImage.optional(),
+  renderError: FigmaNodeRenderError.optional(),
+
+  hasSource: z.boolean(),
+});
+
+export const DTOFigmaNodeV2 = FigmaNodeReference.omit({
+  data: true,
+  origin: true,
+}).extend({
+  data: DTOFigmaNodeDataV2,
+  origin: DTOFigmaNodeOrigin,
+});
+
+export type DTOFigmaNodeDataV2 = z.infer<typeof DTOFigmaNodeDataV2>;
+export type DTOFigmaNodeV2 = z.infer<typeof DTOFigmaNodeV2>;

package/src/api/dto/elements/figma-nodes/figma-node.ts

@@ -0,0 +1,103 @@
+import { FigmaNodeRenderFormat } from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Enums
+//
+
+export const DTOFigmaNodeRenderFormat = FigmaNodeRenderFormat;
+export type DTOFigmaNodeRenderFormat = z.infer<typeof DTOFigmaNodeRenderFormat>;
+
+//
+// Read
+//
+
+export const DTOFigmaNodeOrigin = z.object({
+  sourceId: z.string(),
+  fileId: z.string().optional(),
+  parentName: z.string().optional(),
+});
+
+export type DTOFigmaNodeOrigin = z.infer<typeof DTOFigmaNodeOrigin>;
+
+//
+// Write
+//
+
+/**
+ * Properties that are available on all types of Figma node render requests
+ */
+const DTOFigmaNodeRenderInputBase = z.object({
+  /**
+   * Format in which the node must be rendered, png by default.
+   */
+  format: FigmaNodeRenderFormat.default("Png"),
+
+  /**
+   * Scale to apply to PNG images, can be between 1 and 4. Scale is ignored for other image formats.
+   */
+  scale: z.number().optional(),
+});
+
+/**
+ * Figma node render request that uses source ID + node ID to identify the requested
+ * node to render. The node ID can be obtained from the source's Figma node structure.
+ */
+export const DTOFigmaNodeRenderIdInput = DTOFigmaNodeRenderInputBase.extend({
+  inputType: z
+    .literal("NodeId")
+    .optional()
+    .transform(v => v ?? "NodeId"),
+
+  /**
+   * Id of a design system's data source representing a linked Figma file
+   */
+  sourceId: z.string(),
+
+  /**
+   * Id of a node within the Figma file
+   */
+  figmaFileNodeId: z.string(),
+});
+
+/**
+ * Figma node render request that uses Figma URL to identify the requested
+ * node to render. The URL can be obtained by the user directly from the Figma app.
+ */
+export const DTOFigmaNodeRenderUrlInput = DTOFigmaNodeRenderInputBase.extend({
+  inputType: z.literal("URL"),
+
+  /**
+   * Id of a design system's data source representing a linked Figma file
+   */
+  figmaNodeUrl: z.string(),
+
+  /**
+   * Brand persistent id to use in case a source has to be created for this render
+   */
+  brandPersistentId: z.string(),
+});
+
+/**
+ * Figma node render request that uses Figma URL to identify the requested
+ * node to render. The URL can be obtained by the user directly from the Figma app.
+ */
+export const DTOFigmaNodeRerenderInput = z.object({
+  inputType: z.literal("Rerender"),
+
+  /**
+   * Persistent ID of an existing Figma node
+   */
+  figmaNodePersistentId: z.string(),
+});
+
+export const DTOFigmaNodeRenderInput = z.discriminatedUnion("inputType", [
+  DTOFigmaNodeRenderIdInput,
+  DTOFigmaNodeRenderUrlInput,
+  DTOFigmaNodeRerenderInput,
+]);
+
+export type DTOFigmaNodeRenderIdInput = z.infer<typeof DTOFigmaNodeRenderIdInput>;
+export type DTOFigmaNodeRenderUrlInput = z.infer<typeof DTOFigmaNodeRenderUrlInput>;
+export type DTOFigmaNodeRerenderInput = z.infer<typeof DTOFigmaNodeRerenderInput>;
+export type DTOFigmaNodeRenderInput = z.infer<typeof DTOFigmaNodeRenderInput>;

package/src/api/dto/elements/figma-nodes/index.ts

@@ -0,0 +1,5 @@
+export * from "./figma-node-structure";
+export * from "./figma-node-v1";
+export * from "./figma-node-v2";
+export * from "./figma-node";
+export * from "./node-actions-v2";

package/src/api/dto/elements/figma-nodes/node-actions-v2.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { DTOFigmaNodeRenderInput } from "./figma-node";
+import { DTOFigmaNodeV2 } from "./figma-node-v2";
+
+//
+// Read
+//
+
+export const DTOFigmaNodeRenderAsyncActionOutput = z.object({
+  type: z.literal("FigmaNodeRenderAsync"),
+  figmaNodes: z.array(DTOFigmaNodeV2),
+});
+
+export type DTOFigmaNodeRenderAsyncActionOutput = z.infer<typeof DTOFigmaNodeRenderAsyncActionOutput>;
+
+//
+// Read
+//
+
+export const DTOFigmaNodeRenderAsyncActionInput = z.object({
+  type: z.literal("FigmaNodeRenderAsync"),
+  nodes: DTOFigmaNodeRenderInput.array(),
+});
+
+export type DTOFigmaNodeRenderAsyncActionInput = z.infer<typeof DTOFigmaNodeRenderAsyncActionInput>;

package/src/api/dto/elements/frame-node-structures/frame-node-structure.ts

@@ -0,0 +1,17 @@
+import { FigmaFileStructureOrigin, FigmaFileStructureStatistics } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOFrameNodeStructure = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+  origin: FigmaFileStructureOrigin,
+  assetsInFile: FigmaFileStructureStatistics,
+});
+
+export const DTOFrameNodeStructureListResponse = z.object({
+  structures: DTOFrameNodeStructure.array(),
+});
+
+export type DTOFrameNodeStructure = z.infer<typeof DTOFrameNodeStructure>;
+export type DTOFrameNodeStructureListResponse = z.infer<typeof DTOFrameNodeStructureListResponse>;

package/src/api/dto/elements/frame-node-structures/index.ts

@@ -0,0 +1 @@
+export * from "./frame-node-structure";

package/src/api/dto/elements/get-elements-v2.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { DTOFigmaNode, DTOFigmaNodeV2 } from "./figma-nodes";
+
+//
+// Read
+//
+
+export const DTOElementsGetTypeFilter = z.enum(["FigmaNode"]);
+
+export const DTOElementsGetQuerySchema = z.object({
+  types: z.string().transform(val => val.split(",").map(v => DTOElementsGetTypeFilter.parse(v))),
+  responseVersion: z.coerce.number().default(1),
+});
+
+export const DTOElementsGetOutput = z.object({
+  figmaNodes: z.array(DTOFigmaNode).optional(),
+});
+
+export const DTOElementsGetOutputV2 = z.object({
+  figmaNodes: z.array(DTOFigmaNodeV2).optional(),
+});
+
+export type DTOElementsGetOutput = z.infer<typeof DTOElementsGetOutput>;
+export type DTOElementsGetOutputV2 = z.infer<typeof DTOElementsGetOutputV2>;
+export type DTOElementsGetQueryRaw = z.input<typeof DTOElementsGetQuerySchema>;
+export type DTOElementsGetQueryParsed = z.output<typeof DTOElementsGetQuerySchema>;
+export type DTOElementsGetTypeFilter = z.infer<typeof DTOElementsGetTypeFilter>;

package/src/api/dto/elements/index.ts

@@ -0,0 +1,7 @@
+export * from "./components";
+export * from "./documentation";
+export * from "./figma-nodes";
+export * from "./frame-node-structures";
+export * from "./properties";
+export * from "./elements-action-v2";
+export * from "./get-elements-v2";

package/src/api/dto/elements/properties/index.ts

@@ -0,0 +1,2 @@
+export * from "./property-definitions";
+export * from "./property-values";

package/src/api/dto/elements/properties/property-definitions.ts

@@ -0,0 +1,75 @@
+import {
+  ElementPropertyImmutableType,
+  ElementPropertyLinkType,
+  ElementPropertyTargetType,
+  ElementPropertyTypeSchema,
+  nullishToOptional,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOColorTokenInlineData } from "../../aux";
+import { DTOObjectMeta } from "../../aux/meta";
+
+const CODE_NAME_REGEX = /^[a-zA-Z_$][a-zA-Z_$0-9-]{1,99}$/;
+
+export const DTOElementPropertyDefinitionOption = z.object({
+  id: z.string(),
+  name: z.string(),
+  backgroundColor: DTOColorTokenInlineData.optional(),
+});
+
+// DTO Object
+export const DTOElementPropertyDefinition = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  meta: DTOObjectMeta,
+  persistentId: z.string(),
+  type: ElementPropertyTypeSchema,
+  targetElementType: ElementPropertyTargetType,
+  codeName: z.string().regex(CODE_NAME_REGEX),
+  options: nullishToOptional(z.array(DTOElementPropertyDefinitionOption)),
+  linkElementType: nullishToOptional(ElementPropertyLinkType),
+  isImmutable: z.boolean(),
+  immutablePropertyType: ElementPropertyImmutableType.optional(),
+});
+
+export type DTOElementPropertyDefinitionOption = z.infer<typeof DTOElementPropertyDefinitionOption>;
+export type DTOElementPropertyDefinition = z.infer<typeof DTOElementPropertyDefinition>;
+
+//
+// Read
+//
+
+export const DTOElementPropertyDefinitionListResponse = z.object({
+  definitions: z.array(DTOElementPropertyDefinition),
+});
+
+export const DTOElementPropertyDefinitionResponse = z.object({
+  definition: DTOElementPropertyDefinition,
+});
+
+export type DTOElementPropertyDefinitionListResponse = z.infer<typeof DTOElementPropertyDefinitionListResponse>;
+export type DTOElementPropertyDefinitionResponse = z.infer<typeof DTOElementPropertyDefinitionResponse>;
+
+//
+// Write
+//
+
+export const DTOElementPropertyDefinitionCreatePayload = z.object({
+  meta: DTOObjectMeta,
+  persistentId: z.string(),
+  type: ElementPropertyTypeSchema,
+  targetElementType: ElementPropertyTargetType,
+  codeName: z.string().regex(CODE_NAME_REGEX),
+  options: nullishToOptional(z.array(DTOElementPropertyDefinitionOption)),
+  linkElementType: nullishToOptional(ElementPropertyLinkType),
+  columnWidth: z.number().max(1024).optional(),
+});
+
+export const DTOElementPropertyDefinitionUpdatePayload = z.object({
+  meta: DTOObjectMeta.optional(),
+  codeName: z.string().regex(CODE_NAME_REGEX).optional(),
+  options: z.array(DTOElementPropertyDefinitionOption).optional(),
+});
+
+export type DTOElementPropertyDefinitionCreatePayload = z.infer<typeof DTOElementPropertyDefinitionCreatePayload>;
+export type DTOElementPropertyDefinitionUpdatePayload = z.infer<typeof DTOElementPropertyDefinitionUpdatePayload>;

package/src/api/dto/elements/properties/property-values.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTOElementPropertyValue = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  definitionId: z.string(),
+  targetElementId: z.string(),
+  value: z.union([z.string(), z.number(), z.boolean()]).optional(),
+  valuePreview: z.string().optional(),
+});
+
+export const DTOElementPropertyValueListResponse = z.object({
+  values: z.array(DTOElementPropertyValue),
+});
+
+export const DTOElementPropertyValueResponse = z.object({
+  value: DTOElementPropertyValue,
+});
+
+export const DTOElementPropertyValuesEditActionOutput = z.object({
+  type: z.literal("ElementPropertyValuesEdit"),
+  output: z.object({ success: z.literal(true) }),
+});
+
+export type DTOElementPropertyValue = z.infer<typeof DTOElementPropertyValue>;
+export type DTOElementPropertyValueListResponse = z.infer<typeof DTOElementPropertyValueListResponse>;
+export type DTOElementPropertyValueResponse = z.infer<typeof DTOElementPropertyValueResponse>;
+export type DTOElementPropertyValuesEditActionOutput = z.infer<typeof DTOElementPropertyValuesEditActionOutput>;
+
+//
+// Write
+//
+
+export const DTOElementPropertyValueUpsertPaylod = z.object({
+  definitionId: z.string(),
+  targetElementId: z.string(),
+  value: z.string().or(z.number()).or(z.boolean()).nullable(),
+});
+
+export const DTOElementPropertyValuesEditActionInput = z.object({
+  type: z.literal("ElementPropertyValuesEdit"),
+  values: DTOElementPropertyValueUpsertPaylod.array(),
+});
+
+export type DTOElementPropertyValueUpsertPaylod = z.infer<typeof DTOElementPropertyValueUpsertPaylod>;
+export type DTOElementPropertyValuesEditActionInput = z.infer<typeof DTOElementPropertyValuesEditActionInput>;

package/src/api/dto/events/forge-project.ts

@@ -0,0 +1,51 @@
+import { Id } from "@supernova-studio/model";
+import z from "zod";
+import { DTOFeatureIteration, DTOFeatureIterationTag, DTOFeatureSandbox } from "../forge";
+import { DTOForgeProjectMember } from "../forge/project-member";
+
+export const DTOForgeProjectMembersCreated = z.object({
+  type: z.literal("ProjectMembersCreated"),
+  data: z.array(DTOForgeProjectMember),
+});
+
+export const DTOForgeProjectMemberUpdated = z.object({
+  type: z.literal("ProjectMemberUpdated"),
+  data: DTOForgeProjectMember,
+});
+
+export const DTOForgeProjectMemberDeleted = z.object({
+  type: z.literal("ProjectMemberDeleted"),
+  data: DTOForgeProjectMember.pick({ userId: true }),
+});
+
+export const DTOForgeProjectIterationTagSet = z.object({
+  type: z.literal("ProjectIterationTagSet"),
+  data: DTOFeatureIterationTag,
+});
+
+export const DTOForgeProjectFeatureSandboxUpdated = z.object({
+  type: z.literal("ProjectFeatureSandboxUpdated"),
+  data: DTOFeatureSandbox,
+});
+
+export const DTOForgeProjectIterationUpdated = z.object({
+  type: z.literal("ProjectIterationUpdated"),
+  data: DTOFeatureIteration.extend({ featureId: Id }),
+});
+
+export const DTOForgeProjectRoomEvent = z.discriminatedUnion("type", [
+  DTOForgeProjectMembersCreated,
+  DTOForgeProjectMemberUpdated,
+  DTOForgeProjectMemberDeleted,
+  DTOForgeProjectIterationTagSet,
+  DTOForgeProjectFeatureSandboxUpdated,
+  DTOForgeProjectIterationUpdated,
+]);
+
+export type DTOForgeProjectMembersCreated = z.infer<typeof DTOForgeProjectMembersCreated>;
+export type DTOForgeProjectMemberUpdated = z.infer<typeof DTOForgeProjectMemberUpdated>;
+export type DTOForgeProjectMemberDeleted = z.infer<typeof DTOForgeProjectMemberDeleted>;
+export type DTOForgeProjectIterationTagSet = z.infer<typeof DTOForgeProjectIterationTagSet>;
+export type DTOForgeProjectFeatureSandboxUpdated = z.infer<typeof DTOForgeProjectFeatureSandboxUpdated>;
+export type DTOForgeProjectIterationUpdated = z.infer<typeof DTOForgeProjectIterationUpdated>;
+export type DTOForgeProjectRoomEvent = z.infer<typeof DTOForgeProjectRoomEvent>;

package/src/api/dto/events/index.ts

@@ -0,0 +1,2 @@
+export * from "./forge-project";
+export * from "./workspace";

package/src/api/dto/events/workspace.ts

@@ -0,0 +1,81 @@
+import z from "zod";
+import { DTOCodeScanListItem } from "../design-systems/code-scan";
+import { DTOForgeProjectContextV2 } from "../forge/project-context-v2";
+
+export const DTOForgeProjectCreated = z.object({
+  type: z.literal("ProjectCreated"),
+  data: z.object({ id: z.string() }),
+});
+
+export const DTOForgeProjectUpdated = z.object({
+  type: z.literal("ProjectUpdated"),
+  data: z.object({ id: z.string() }),
+});
+
+export const DTOForgeProjectContextCreated = z.object({
+  type: z.literal("ProjectContextCreated"),
+  data: DTOForgeProjectContextV2,
+});
+
+export const DTOForgeProjectContextUpdated = z.object({
+  type: z.literal("ProjectContextUpdated"),
+  data: DTOForgeProjectContextV2,
+});
+
+export const DTOForgeProjectContextDeleted = z.object({
+  type: z.literal("ProjectContextDeleted"),
+  data: DTOForgeProjectContextV2.pick({ id: true }),
+});
+
+export const DTOSandboxTemplateVersionCreated = z.object({
+  type: z.literal("SandboxTemplateVersionCreated"),
+  data: z.object({
+    templateId: z.string(),
+    version: z.string(),
+    designSystemId: z.string(),
+  }),
+});
+
+export const DTOSandboxTemplateBuildCreated = z.object({
+  type: z.literal("SandboxTemplateBuildCreated"),
+  data: z.object({
+    buildId: z.string(),
+    templateId: z.string().optional(),
+  }),
+});
+
+export const DTOSandboxTemplateBuildFinished = z.object({
+  type: z.literal("SandboxTemplateBuildFinished"),
+  data: z.object({
+    buildId: z.string(),
+    templateId: z.string().optional(),
+  }),
+});
+
+export const DTOCodeScanFinished = z.object({
+  type: z.literal("CodeScanFinished"),
+  data: DTOCodeScanListItem,
+});
+
+export const DTOWorkspaceRoomEvent = z.discriminatedUnion("type", [
+  DTOForgeProjectUpdated,
+  DTOForgeProjectCreated,
+  DTOForgeProjectContextCreated,
+  DTOForgeProjectContextUpdated,
+  DTOForgeProjectContextDeleted,
+  DTOSandboxTemplateVersionCreated,
+  DTOSandboxTemplateBuildCreated,
+  DTOSandboxTemplateBuildFinished,
+  DTOCodeScanFinished,
+]);
+
+export type DTOForgeProjectCreated = z.infer<typeof DTOForgeProjectCreated>;
+export type DTOForgeProjectUpdated = z.infer<typeof DTOForgeProjectUpdated>;
+export type DTOForgeProjectContextCreated = z.infer<typeof DTOForgeProjectContextCreated>;
+export type DTOForgeProjectContextUpdated = z.infer<typeof DTOForgeProjectContextUpdated>;
+export type DTOForgeProjectContextDeleted = z.infer<typeof DTOForgeProjectContextDeleted>;
+export type DTOSandboxTemplateVersionCreated = z.infer<typeof DTOSandboxTemplateVersionCreated>;
+export type DTOSandboxTemplateBuildCreated = z.infer<typeof DTOSandboxTemplateBuildCreated>;
+export type DTOSandboxTemplateBuildFinished = z.infer<typeof DTOSandboxTemplateBuildFinished>;
+export type DTOCodeScanFinished = z.infer<typeof DTOCodeScanFinished>;
+export type DTOWorkspaceRoomEvent = z.infer<typeof DTOWorkspaceRoomEvent>;