@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/forge/artifact.ts

@@ -0,0 +1,94 @@
+import {
+  ForgeArtifact,
+  ForgeBuildArtifact,
+  ForgeFigmaArtifact,
+  ForgeFileArtifact,
+  ForgeSpecArtifact,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOCreateForgeBuildArtifact = ForgeBuildArtifact.omit({
+  id: true,
+  createdAt: true,
+  projectIterationId: true,
+});
+export const DTOCreateForgeFileArtifact = ForgeFileArtifact.omit({
+  id: true,
+  createdAt: true,
+  projectIterationId: true,
+});
+export const DTOCreateForgeFigmaArtifact = ForgeFigmaArtifact.omit({
+  id: true,
+  createdAt: true,
+  projectIterationId: true,
+});
+export const DTOCreateForgeSpecArtifact = ForgeSpecArtifact.omit({
+  id: true,
+  createdAt: true,
+  projectIterationId: true,
+});
+
+export const DTOUpdateForgeBuildArtifact = DTOCreateForgeBuildArtifact.extend({ id: z.string() });
+export const DTOUpdateForgeFileArtifact = DTOCreateForgeFileArtifact.extend({ id: z.string() });
+export const DTOUpdateForgeFigmaArtifact = DTOCreateForgeFigmaArtifact.extend({ id: z.string() });
+export const DTOUpdateForgeSpecArtifact = DTOCreateForgeSpecArtifact.extend({ id: z.string() });
+
+export const DTOForgeArtifact = ForgeArtifact;
+export const DTOForgeBuildArtifact = ForgeBuildArtifact;
+export const DTOForgeFileArtifact = ForgeFileArtifact;
+export const DTOForgeFigmaArtifact = ForgeFigmaArtifact;
+export const DTOForgeSpecArtifact = ForgeSpecArtifact;
+
+export const DTOCreateForgeArtifact = z.union([
+  DTOCreateForgeBuildArtifact,
+  DTOCreateForgeFileArtifact,
+  DTOCreateForgeFigmaArtifact,
+  DTOCreateForgeSpecArtifact,
+]);
+export const DTOUpdateForgeArtifact = z.union([
+  DTOUpdateForgeFileArtifact,
+  DTOUpdateForgeBuildArtifact,
+  DTOUpdateForgeSpecArtifact,
+  DTOUpdateForgeFigmaArtifact,
+]);
+
+export const DTOCreateForgeArtifactResponse = z.object({
+  artifact: DTOForgeArtifact,
+});
+
+export const DTOUpdateForgeArtifactResponse = z.object({
+  artifact: DTOForgeArtifact.nullable(),
+});
+
+export const DTODeleteForgeArtifactResponse = z.object({
+  ok: z.literal(true),
+});
+
+export const DTOForgeArtifactsListResponse = z.object({
+  artifacts: z.array(DTOForgeArtifact),
+});
+
+export const DTOForgeArtifactGetResponse = z.object({
+  artifact: DTOForgeArtifact.nullable(),
+});
+
+export type DTOForgeArtifactsListResponse = z.infer<typeof DTOForgeArtifactsListResponse>;
+export type DTOForgeArtifactGetResponse = z.infer<typeof DTOForgeArtifactGetResponse>;
+export type DTOForgeArtifact = z.infer<typeof DTOForgeArtifact>;
+export type DTOForgeBuildArtifact = z.infer<typeof DTOForgeBuildArtifact>;
+export type DTOForgeFileArtifact = z.infer<typeof DTOForgeFileArtifact>;
+export type DTOForgeFigmaArtifact = z.infer<typeof DTOForgeFigmaArtifact>;
+export type DTOForgeSpecArtifact = z.infer<typeof DTOForgeSpecArtifact>;
+export type DTOCreateForgeArtifact = z.infer<typeof DTOCreateForgeArtifact>;
+export type DTOUpdateForgeArtifact = z.infer<typeof DTOUpdateForgeArtifact>;
+export type DTOCreateForgeArtifactResponse = z.infer<typeof DTOCreateForgeArtifactResponse>;
+export type DTOUpdateForgeArtifactResponse = z.infer<typeof DTOUpdateForgeArtifactResponse>;
+export type DTODeleteForgeArtifactResponse = z.infer<typeof DTODeleteForgeArtifactResponse>;
+export type DTOCreateForgeBuildArtifact = z.infer<typeof DTOCreateForgeBuildArtifact>;
+export type DTOCreateForgeFileArtifact = z.infer<typeof DTOCreateForgeFileArtifact>;
+export type DTOCreateForgeFigmaArtifact = z.infer<typeof DTOCreateForgeFigmaArtifact>;
+export type DTOCreateForgeSpecArtifact = z.infer<typeof DTOCreateForgeSpecArtifact>;
+export type DTOUpdateForgeBuildArtifact = z.infer<typeof DTOUpdateForgeBuildArtifact>;
+export type DTOUpdateForgeFileArtifact = z.infer<typeof DTOUpdateForgeFileArtifact>;
+export type DTOUpdateForgeSpecArtifact = z.infer<typeof DTOUpdateForgeSpecArtifact>;
+export type DTOUpdateForgeFigmaArtifact = z.infer<typeof DTOUpdateForgeFigmaArtifact>;

package/src/api/dto/forge/feature-messages.ts

@@ -0,0 +1,551 @@
+import { Id } from "@supernova-studio/model";
+import z from "zod";
+import { DTOFileReference } from "../files";
+
+//
+// Data model
+//
+
+export const DTOFeatureMessageUserSender = z.object({
+  type: z.literal("User"),
+  userId: z.string(),
+});
+
+export const DTOFeatureMessageAgentSender = z.object({
+  type: z.literal("Agent"),
+});
+
+export const DTOFeatureMessageSystemSender = z.object({
+  type: z.literal("System"),
+  onBehalfOfUserId: z.string(),
+});
+
+export const DTOFeatureMessageSender = z.discriminatedUnion("type", [
+  DTOFeatureMessageUserSender,
+  DTOFeatureMessageAgentSender,
+  DTOFeatureMessageSystemSender,
+]);
+
+export const DTOFeatureMessageReaction = z.object({
+  messageId: Id,
+  userId: z.string(),
+  emoji: z.string(),
+  createdAt: z.string(),
+});
+
+export const DTOFeatureMessageAttachments = z.object({
+  iterationId: Id.optional(),
+
+  // TODO Artem: files, etc
+});
+
+export const DTOFeatureMessage = z.object({
+  id: Id,
+
+  /**
+   * Describes where the message came from
+   */
+  sender: DTOFeatureMessageSender,
+
+  /**
+   * Content of the message
+   */
+  body: z.string(),
+
+  /**
+   * Indicates if the message was sent in the agentic mode, if so this message will cause an
+   * AI agent to generate a response and perform an action within the feature
+   */
+  isPrompt: z.boolean().optional(),
+
+  /**
+   * Indicates if the sender requested agent to reply in a thread
+   */
+  startsNewThread: z.boolean().optional(),
+
+  /**
+   * If defined, this message is considered to be a reply in a thread under parent message id
+   */
+  parentMessageId: Id.optional(),
+
+  /**
+   * Link agent response object describing current state of
+   */
+  agentResponseTrackerId: Id.optional().nullable(),
+
+  attachments: DTOFeatureMessageAttachments.optional(),
+
+  /**
+   * If defined, this message is considered to be a reply to different message
+   */
+  replyToMessageId: Id.optional(),
+
+  createdAt: z.string(),
+  updatedAt: z.string().optional(),
+});
+
+export const DTOFeatureAgentResponseTracker = z.object({
+  id: Id,
+  currentBody: z.string().default(""),
+});
+
+export const DTOFeatureArtifact = z.object({
+  id: Id,
+
+  /**
+   * Key of the artifact, can include path like `src/components/button.tsx`
+   */
+  key: z.string(),
+
+  /**
+   * Id of the project file that holds content of this artifact
+   */
+  fileId: z.string().optional(),
+
+  /**
+   * Id of the Iteration that this artifact belongs to
+   */
+  iterationId: Id.optional(),
+
+  /**
+   * URL of the feature artifact's contents
+   */
+  url: z.string(),
+
+  /**
+   * Relative file path of the artifact (without domain/base URL)
+   */
+  filePath: z.string().optional(),
+
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export const DTOFeatureIterationArtifactsDiff = z.object({
+  created: z.array(DTOFeatureArtifact.shape.key).optional().default([]),
+  updated: z.array(DTOFeatureArtifact.shape.key).optional().default([]),
+  deleted: z.array(DTOFeatureArtifact.shape.key).optional().default([]),
+});
+
+export const DTOFeatureIterationState = z.enum(["InProgress", "Success", "Error", "Timeout"]);
+export const DTOFeatureIterationErrorType = z.enum(["PackageInstall", "Build", "Compile", "Unknown", "Runtime"]);
+
+export const DTOFeatureIterationError = z.object({
+  description: z.string(),
+  type: DTOFeatureIterationErrorType,
+});
+
+export const DTOFeatureIteration = z.object({
+  id: Id,
+
+  /**
+   * Name of the iteration
+   */
+  name: z.string(),
+
+  /**
+   * ID of the iteration that this iteration is based on
+   */
+  baseIterationId: z.string().optional(),
+
+  /**
+   * Message ID that triggered creation of the iteration
+   */
+  startedFromMessageId: z.string(),
+
+  /**
+   * Indicates whether the iteration is currently being generated by an agent
+   * @deprecated use `state`
+   */
+  isInProgress: z.boolean().optional(),
+
+  /**
+   * Indicates current processing (creation) state of this iteration.
+   * This property is optional only for backward compatibility with data stored in Liveblocks rooms.
+   * It can be treated as non-optional (undefined doesn't have any meaning here).
+   *
+   * - InProgress: iteration is being created by an AI agent
+   * - Success: iteration has been successfully finished and is ready to be consumed
+   * - Error: an error has occured during iteration processing, the iteration cannot be consumed
+   * - Timeout: the iteration hasn't been finished in a reasonable time, the iteration cannot be consumed
+   */
+  state: DTOFeatureIterationState.optional(),
+
+  /**
+   * Description of a sandbox error if there were any (such as during `npm i` or `npm run dev`).
+   * To be used for "fix with AI"
+   *
+   * @deprecated use `error.description` instead
+   */
+  errorDescription: z.string().nullish(),
+
+  /**
+   * Description of a sandbox error if there were any (such as during `npm i` or `npm run build`).
+   * To be used for "fix with AI"
+   */
+  error: DTOFeatureIterationError.optional(),
+
+  /**
+   * The cost in credits to generate this iteration
+   */
+  creditsCost: z.number().optional(),
+
+  /**
+   * URL of a static preview of the feature
+   */
+  staticPreviewUrl: z.string().optional(),
+
+  /**
+   * Indicates whether the iteration is bookmarked by user
+   */
+  isBookmarked: z.boolean().optional(),
+
+  /**
+   * @deprecated use thumbnail.fileUrl
+   * URL of a static thumbnail of the feature iteration
+   */
+  thumbnailUrl: z.string().optional(),
+
+  thumbnail: DTOFileReference.optional(),
+
+  createdAt: z.string(),
+  updatedAt: z.string().optional(),
+
+  artifactsDiff: DTOFeatureIterationArtifactsDiff.optional().nullable(),
+});
+
+export const DTOFeatureIterationTag = z.object({
+  id: Id,
+  featureId: Id,
+
+  /**
+   * If defined, this latest tag is specific to a message thread.
+   * If null, this is the latest tag for the entire feature.
+   */
+  messageId: Id.optional(),
+
+  /**
+   * The iteration that is marked as latest for this context
+   */
+  iterationId: Id,
+});
+
+export const DTOSandboxError = z.object({
+  /** At what stage the error has occured */
+  stage: z.enum(["PackageInstall", "HealthCheck", "Build", "Unknown"]),
+
+  /** We will use this in "fix with AI" */
+  errorDescription: z.string(),
+});
+
+export const DTOFeatureSandbox = z.object({
+  id: z.string(),
+  url: z.string(),
+  parentMessageId: Id.optional(),
+  currentIterationId: Id,
+  featureId: Id,
+  expiresAt: z.string(),
+  error: DTOSandboxError.optional(),
+});
+
+export const DTOCreateFeatureSandbox = DTOFeatureSandbox.extend({
+  isSystemSandbox: z.boolean().optional(),
+});
+export const DTOUpdateFeatureSandbox = DTOCreateFeatureSandbox.partial().extend({
+  id: z.string(),
+  parentMessageId: Id.nullish(),
+  expiresAt: z.string().optional(),
+  error: DTOSandboxError.nullish(),
+});
+
+export const DTOFeatureSandboxListResponse = z.object({
+  sandboxes: DTOFeatureSandbox.array(),
+});
+
+export type DTOFeatureIterationArtifactsDiff = z.infer<typeof DTOFeatureIterationArtifactsDiff>;
+export type DTOFeatureMessageUserSender = z.infer<typeof DTOFeatureMessageUserSender>;
+export type DTOFeatureMessageAgentSender = z.infer<typeof DTOFeatureMessageAgentSender>;
+export type DTOFeatureMessageSystemSender = z.infer<typeof DTOFeatureMessageSystemSender>;
+export type DTOFeatureMessageSender = z.infer<typeof DTOFeatureMessageSender>;
+export type DTOFeatureAgentResponseTracker = z.infer<typeof DTOFeatureAgentResponseTracker>;
+export type DTOFeatureMessageReaction = z.infer<typeof DTOFeatureMessageReaction>;
+export type DTOFeatureMessage = z.infer<typeof DTOFeatureMessage>;
+export type DTOFeatureArtifact = z.infer<typeof DTOFeatureArtifact>;
+export type DTOFeatureIterationState = z.infer<typeof DTOFeatureIterationState>;
+export type DTOFeatureIterationErrorType = z.infer<typeof DTOFeatureIterationErrorType>;
+export type DTOFeatureIterationError = z.infer<typeof DTOFeatureIterationError>;
+export type DTOFeatureIteration = z.infer<typeof DTOFeatureIteration>;
+export type DTOFeatureIterationTag = z.infer<typeof DTOFeatureIterationTag>;
+export type DTOSandboxError = z.infer<typeof DTOSandboxError>;
+export type DTOFeatureSandbox = z.infer<typeof DTOFeatureSandbox>;
+export type DTOCreateFeatureSandbox = z.infer<typeof DTOCreateFeatureSandbox>;
+export type DTOUpdateFeatureSandbox = z.infer<typeof DTOUpdateFeatureSandbox>;
+export type DTOFeatureSandboxListResponse = z.infer<typeof DTOFeatureSandboxListResponse>;
+export type DTOFeatureMessageAttachments = z.infer<typeof DTOFeatureMessageAttachments>;
+
+export const DTOProvisionFeatureSandboxInput = z.object({
+  parentMessageId: z.string().optional(),
+});
+
+export const DTOProvisionFeatureSandboxResponse = z.object({
+  ok: z.boolean(),
+});
+
+export const DTOKeepAliveFeatureSandboxResponse = z.object({
+  sandbox: DTOFeatureSandbox,
+});
+
+export type DTOProvisionFeatureSandboxInput = z.infer<typeof DTOProvisionFeatureSandboxInput>;
+export type DTOProvisionFeatureSandboxResponse = z.infer<typeof DTOProvisionFeatureSandboxResponse>;
+export type DTOKeepAliveFeatureSandboxResponse = z.infer<typeof DTOKeepAliveFeatureSandboxResponse>;
+
+//
+// Payloads
+//
+
+export const DTOFeatureMessageCreateInput = DTOFeatureMessage.pick({
+  id: true,
+  body: true,
+  isPrompt: true,
+  startsNewThread: true,
+  parentMessageId: true,
+  attachments: true,
+});
+
+export const DTOFeatureMessageUpdateInput = DTOFeatureMessageCreateInput.omit({ id: true })
+  .merge(DTOFeatureMessage.pick({ agentResponseTrackerId: true }))
+  .partial();
+
+export const DTOFeatureMessageReactionCreateInput = z.object({
+  messageId: Id,
+  emoji: z.string(),
+});
+
+export const DTOFeatureMessageReactionDeleteInput = z.object({
+  messageId: Id,
+  emoji: z.string(),
+});
+
+export const DTOFeatureArtifactCreateInput = z.object({
+  id: Id,
+  key: z.string(),
+  fileId: z.string(),
+  iterationId: Id.optional(),
+});
+
+export const DTOFeatureArtifactDeleteInput = z.object({
+  id: Id,
+});
+
+export const DTOFeatureIterationCreateInput = DTOFeatureIteration.pick({
+  id: true,
+  startedFromMessageId: true,
+});
+
+export const DTOFeatureIterationPromoteInput = z.object({
+  id: Id,
+});
+
+export const DTOFeatureArtifactGetByIdParam = z.object({
+  id: Id,
+});
+
+export const DTOFeatureIterationSetLatestInput = z.object({
+  id: Id,
+  /**
+   * Optional message ID to determine the context for setting this iteration as latest.
+   * When provided, uses this message's parent as the tag context.
+   * When undefined, uses the iteration's original startedFromMessage.
+   * When null, explicitly excludes message context from the tag.
+   */
+  contextMessageId: Id.nullish(),
+});
+
+export const DTOFeatureIterationUpdateInput = z.object({
+  id: Id,
+  isBookmarked: z.boolean().optional(),
+});
+
+export const DTOFeatureIterationTagCreateInput = z.object({
+  featureId: Id,
+  iterationId: Id,
+  messageId: Id.optional(),
+});
+
+export const DTOFeatureIterationArtifactDiff = z.object({
+  /**
+   * Map of artifact key -> new key that describes artifacts that will be moved in this iteration
+   */
+  move: z.record(
+    z.object({
+      newKey: z.string(),
+    })
+  ),
+
+  /**
+   * Map of artifact key -> new key that describes artifacts that will be copied in this iteration
+   */
+  copy: z
+    .record(
+      z.object({
+        newKey: z.string(),
+      })
+    )
+    .optional(),
+
+  /**
+   * Map of artifact key -> artifact content that describes artifacts that will be
+   * create or updated in this iteration
+   */
+  upsert: z.record(
+    z.object({
+      artifactContent: z.string(),
+    })
+  ),
+
+  /**
+   * List artifact keys to remove from this iteration
+   */
+  remove: z.array(z.string()),
+});
+
+export const DTOFeatureIterationUpdateArtifactsInput = z.object({
+  id: Id,
+  name: z.string().optional(),
+  artifactDiff: DTOFeatureIterationArtifactDiff,
+});
+
+export const DTOFeatureIterationValidateInput = z.object({
+  id: Id,
+  messageId: Id,
+});
+
+export const DTOFeatureIterationUpdateArtifactsByMessageInput = z.object({
+  messageId: Id,
+  name: z.string().optional(),
+  artifactDiff: DTOFeatureIterationArtifactDiff,
+});
+
+export const DTOFeatureAgentWorkFinalizeInput = z.object({
+  messageId: Id,
+});
+
+export const DTOFeatureUpdateThemeInput = z.object({
+  parentMessageId: z.string().optional(),
+  themeCss: z.string(),
+});
+
+export type DTOFeatureMessageCreateInput = z.infer<typeof DTOFeatureMessageCreateInput>;
+export type DTOFeatureMessageUpdateInput = z.infer<typeof DTOFeatureMessageUpdateInput>;
+export type DTOFeatureMessageReactionDeleteInput = z.infer<typeof DTOFeatureMessageReactionDeleteInput>;
+export type DTOFeatureMessageReactionCreateInput = z.infer<typeof DTOFeatureMessageReactionCreateInput>;
+export type DTOFeatureArtifactCreateInput = z.infer<typeof DTOFeatureArtifactCreateInput>;
+export type DTOFeatureArtifactDeleteInput = z.infer<typeof DTOFeatureArtifactDeleteInput>;
+export type DTOFeatureIterationCreateInput = z.infer<typeof DTOFeatureIterationCreateInput>;
+export type DTOFeatureIterationPromoteInput = z.infer<typeof DTOFeatureIterationPromoteInput>;
+export type DTOFeatureIterationSetLatestInput = z.infer<typeof DTOFeatureIterationSetLatestInput>;
+export type DTOFeatureIterationUpdateInput = z.infer<typeof DTOFeatureIterationUpdateInput>;
+export type DTOFeatureIterationTagCreateInput = z.infer<typeof DTOFeatureIterationTagCreateInput>;
+export type DTOFeatureIterationArtifactDiff = z.infer<typeof DTOFeatureIterationArtifactDiff>;
+export type DTOFeatureIterationUpdateArtifactsInput = z.infer<typeof DTOFeatureIterationUpdateArtifactsInput>;
+export type DTOFeatureIterationValidateInput = z.infer<typeof DTOFeatureIterationValidateInput>;
+export type DTOFeatureIterationUpdateArtifactsByMessageInput = z.infer<
+  typeof DTOFeatureIterationUpdateArtifactsByMessageInput
+>;
+export type DTOFeatureAgentWorkFinalizeInput = z.infer<typeof DTOFeatureAgentWorkFinalizeInput>;
+export type DTOFeatureUpdateThemeInput = z.infer<typeof DTOFeatureUpdateThemeInput>;
+export type DTOFeatureArtifactGetByIdParam = z.infer<typeof DTOFeatureArtifactGetByIdParam>;
+
+//
+// Responses
+//
+
+export const DTOFeatureMessageResponse = z.object({
+  message: DTOFeatureMessage,
+});
+
+export const DTOFeatureMessageReactionResponse = z.object({
+  reaction: DTOFeatureMessageReaction,
+});
+
+export const DTOFeatureMessageListResponse = z.object({
+  messages: DTOFeatureMessage.array(),
+  reactions: DTOFeatureMessageReaction.array(),
+  lastSeenMessageId: z.string().optional(),
+});
+
+export const DTOFeatureArtifactResponse = z.object({
+  artifact: DTOFeatureArtifact,
+});
+
+export const DTOFeatureArtifactListResponse = z.object({
+  artifacts: DTOFeatureArtifact.array(),
+});
+
+export const DTOFeatureArtifactWithContentResponse = z.object({
+  artifact: DTOFeatureArtifact,
+  content: z.string(),
+});
+
+export const DTOFeatureIterationResponse = z.object({
+  iteration: DTOFeatureIteration,
+});
+
+export const DTOFeatureIterationListResponse = z.object({
+  iterations: DTOFeatureIteration.array(),
+});
+
+export const DTOFeatureIterationValidateResponse = z.discriminatedUnion("success", [
+  z.object({ success: z.literal(true) }),
+  z.object({ success: z.literal(false), error: DTOFeatureIterationError }),
+]);
+
+export const DTOFeatureIterationTagResponse = z.object({
+  tag: DTOFeatureIterationTag,
+});
+
+export const DTOFeatureIterationTagListResponse = z.object({
+  tags: DTOFeatureIterationTag.array(),
+});
+
+export type DTOFeatureMessageResponse = z.infer<typeof DTOFeatureMessageResponse>;
+export type DTOFeatureMessageReactionResponse = z.infer<typeof DTOFeatureMessageReactionResponse>;
+export type DTOFeatureMessageListResponse = z.infer<typeof DTOFeatureMessageListResponse>;
+export type DTOFeatureArtifactResponse = z.infer<typeof DTOFeatureArtifactResponse>;
+export type DTOFeatureArtifactWithContentResponse = z.infer<typeof DTOFeatureArtifactWithContentResponse>;
+export type DTOFeatureArtifactListResponse = z.infer<typeof DTOFeatureArtifactListResponse>;
+export type DTOFeatureIterationListResponse = z.infer<typeof DTOFeatureIterationListResponse>;
+export type DTOFeatureIterationValidateResponse = z.infer<typeof DTOFeatureIterationValidateResponse>;
+export type DTOFeatureIterationResponse = z.infer<typeof DTOFeatureIterationResponse>;
+export type DTOFeatureIterationTagResponse = z.infer<typeof DTOFeatureIterationTagResponse>;
+export type DTOFeatureIterationTagListResponse = z.infer<typeof DTOFeatureIterationTagListResponse>;
+
+//
+// Events
+//
+
+export const DTOFeatureEventMessagesSent = z.object({
+  type: z.literal("MessagesSent"),
+  data: DTOFeatureMessage.array(),
+});
+
+export const DTOFeatureEventReactionsSent = z.object({
+  type: z.literal("ReactionsSent"),
+  data: DTOFeatureMessageReaction.array(),
+});
+
+export const DTOFeatureEventReactionsDeleted = z.object({
+  type: z.literal("ReactionsDeleted"),
+  data: DTOFeatureMessageReaction,
+});
+
+export const DTOFeatureEvent = z.discriminatedUnion("type", [
+  DTOFeatureEventMessagesSent,
+  DTOFeatureEventReactionsSent,
+  DTOFeatureEventReactionsDeleted,
+]);
+
+export type DTOFeatureEventMessagesSent = z.infer<typeof DTOFeatureEventMessagesSent>;
+export type DTOFeatureEventReactionsSent = z.infer<typeof DTOFeatureEventReactionsSent>;
+export type DTOFeatureEventReactionsDeleted = z.infer<typeof DTOFeatureEventReactionsDeleted>;
+export type DTOFeatureEvent = z.infer<typeof DTOFeatureEvent>;

package/src/api/dto/forge/feature-room.ts

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