@supernova-studio/client 1.96.5 → 1.96.7

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

@@ -0,0 +1,46 @@
+import { ForgeProjectInvitation } from "@supernova-studio/model";
+import { z } from "zod";
+
+// Updated DTOs to match the database model
+export const DTOForgeProjectInvitation = ForgeProjectInvitation;
+
+export const DTOCreateForgeProjectInvitation = DTOForgeProjectInvitation.pick({
+  email: true,
+  role: true,
+});
+
+export const DTOUpdateForgeProjectInvitation = DTOCreateForgeProjectInvitation;
+
+export const DTORemoveForgeProjectInvitation = DTOCreateForgeProjectInvitation.pick({
+  email: true,
+});
+
+export const DTOForgeProjectInvitationsListResponse = z.object({
+  invitations: z.array(DTOForgeProjectInvitation),
+});
+
+export const DTOForgeProjectInvitationGetResponse = z.object({
+  invitation: DTOForgeProjectInvitation,
+});
+
+export const DTOForgeProjectInvitationCreateResponse = z.object({
+  invitation: DTOForgeProjectInvitation,
+});
+
+export const DTOForgeProjectInvitationUpdateResponse = z.object({
+  invitation: DTOForgeProjectInvitation.nullable(),
+});
+
+export const DTOForgeProjectInvitationRemoveResponse = z.object({
+  ok: z.literal(true),
+});
+
+export type DTOForgeProjectInvitation = z.infer<typeof DTOForgeProjectInvitation>;
+export type DTOCreateForgeProjectInvitation = z.infer<typeof DTOCreateForgeProjectInvitation>;
+export type DTOUpdateForgeProjectInvitation = z.infer<typeof DTOUpdateForgeProjectInvitation>;
+export type DTORemoveForgeProjectInvitation = z.infer<typeof DTORemoveForgeProjectInvitation>;
+export type DTOForgeProjectInvitationsListResponse = z.infer<typeof DTOForgeProjectInvitationsListResponse>;
+export type DTOForgeProjectInvitationGetResponse = z.infer<typeof DTOForgeProjectInvitationGetResponse>;
+export type DTOForgeProjectInvitationCreateResponse = z.infer<typeof DTOForgeProjectInvitationCreateResponse>;
+export type DTOForgeProjectInvitationUpdateResponse = z.infer<typeof DTOForgeProjectInvitationUpdateResponse>;
+export type DTOForgeProjectInvitationRemoveResponse = z.infer<typeof DTOForgeProjectInvitationRemoveResponse>;

package/src/api/dto/forge/project-iteration-old.ts

@@ -0,0 +1,54 @@
+import { ForgeProjectIteration, ForgeProjectIterationMergeMeta } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOForgeArtifact } from "./artifact";
+import { DTOForgeIterationMessage } from "./iteration-message-old";
+
+export const DTOForgeProjectIterationMergeMeta = ForgeProjectIterationMergeMeta;
+
+export const DTOForgeProjectIteration = ForgeProjectIteration.omit({
+  artifacts: true,
+  messages: true,
+  mergeMeta: true,
+}).extend({
+  artifacts: DTOForgeArtifact.array(),
+  messages: DTOForgeIterationMessage.array(),
+  mergeMeta: DTOForgeProjectIterationMergeMeta.optional(),
+});
+
+export const DTOGetForgeProjectIterationResponse = z.object({
+  iteration: DTOForgeProjectIteration.nullable(),
+});
+
+export const DTOCreateForgeProjectIteration = DTOForgeProjectIteration.omit({
+  forgeProjectId: true,
+  artifacts: true,
+  messages: true,
+  mergeMeta: true,
+  createdAt: true,
+});
+
+export const DTOUpdateForgeProjectIteration = DTOCreateForgeProjectIteration.extend({ id: z.string() });
+
+export const DTOCreateForgeProjectIterationResponse = z.object({
+  iteration: DTOForgeProjectIteration,
+});
+
+export const DTOUpdateForgeProjectIterationResponse = z.object({
+  iteration: DTOForgeProjectIteration.nullable(),
+});
+
+export const DTODeleteForgeProjectIterationResponse = z.object({
+  ok: z.literal(true),
+});
+
+export const DTOForgeProjectIterationListResponse = z.object({ iterations: z.array(DTOForgeProjectIteration) });
+
+export type DTOForgeProjectIterationMergeMeta = z.infer<typeof DTOForgeProjectIterationMergeMeta>;
+export type DTOForgeProjectIteration = z.infer<typeof DTOForgeProjectIteration>;
+export type DTOForgeProjectIterationListResponse = z.infer<typeof DTOForgeProjectIterationListResponse>;
+export type DTOGetForgeProjectIterationResponse = z.infer<typeof DTOGetForgeProjectIterationResponse>;
+export type DTOCreateForgeProjectIteration = z.infer<typeof DTOCreateForgeProjectIteration>;
+export type DTOUpdateForgeProjectIteration = z.infer<typeof DTOUpdateForgeProjectIteration>;
+export type DTOCreateForgeProjectIterationResponse = z.infer<typeof DTOCreateForgeProjectIterationResponse>;
+export type DTOUpdateForgeProjectIterationResponse = z.infer<typeof DTOUpdateForgeProjectIterationResponse>;
+export type DTODeleteForgeProjectIterationResponse = z.infer<typeof DTODeleteForgeProjectIterationResponse>;

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

@@ -0,0 +1,67 @@
+import { ForgeProjectMembership, ForgeProjectRole } from "@supernova-studio/model";
+import { z } from "zod";
+import { zodQueryBoolean } from "../../../utils";
+import { DTOUser } from "../users";
+import { DTOCreateForgeProjectInvitation, DTOForgeProjectInvitation } from "./project-invitation";
+
+export const DTOForgeProjectMemberRole = ForgeProjectRole;
+
+export const DTOForgeProjectMember = ForgeProjectMembership.extend({
+  user: DTOUser,
+  effectiveRole: DTOForgeProjectMemberRole,
+  isDeactivated: z.boolean(),
+});
+
+export const DTOCreateForgeProjectMember = DTOForgeProjectMember.pick({
+  userId: true,
+  role: true,
+});
+
+export const DTOUpdateForgeProjectMember = DTOCreateForgeProjectMember;
+
+export const DTORemoveForgeProjectMember = DTOForgeProjectMember.pick({
+  userId: true,
+});
+
+export const DTOForgeProjectMemberListQuery = z.object({
+  includeImplicitMembers: zodQueryBoolean().optional(),
+});
+
+export const DTOForgeProjectMembersListResponse = z.object({
+  members: z.array(DTOForgeProjectMember),
+  invitations: z.array(DTOForgeProjectInvitation),
+});
+
+export const DTOForgeProjectMemberGetResponse = z.object({
+  member: DTOForgeProjectMember,
+});
+
+export const DTOForgeProjectMemberCreateResponse = z.object({
+  member: DTOForgeProjectMember,
+});
+
+export const DTOForgeProjectMemberUpdateResponse = z.object({
+  member: DTOForgeProjectMember.nullable(),
+});
+
+export const DTOForgeProjectMemberRemoveResponse = z.object({
+  ok: z.literal(true),
+});
+
+export const DTOAddMembersToForgeProject = z.object({
+  membersToInvite: DTOCreateForgeProjectInvitation.array().min(1),
+  featureId: z.string().optional(),
+});
+
+export type DTOForgeProjectMemberRole = z.infer<typeof DTOForgeProjectMemberRole>;
+export type DTOForgeProjectMember = z.infer<typeof DTOForgeProjectMember>;
+export type DTOCreateForgeProjectMember = z.infer<typeof DTOCreateForgeProjectMember>;
+export type DTOUpdateForgeProjectMember = z.infer<typeof DTOUpdateForgeProjectMember>;
+export type DTORemoveForgeProjectMember = z.infer<typeof DTORemoveForgeProjectMember>;
+export type DTOForgeProjectMemberListQuery = z.infer<typeof DTOForgeProjectMemberListQuery>;
+export type DTOForgeProjectMembersListResponse = z.infer<typeof DTOForgeProjectMembersListResponse>;
+export type DTOForgeProjectMemberGetResponse = z.infer<typeof DTOForgeProjectMemberGetResponse>;
+export type DTOForgeProjectMemberCreateResponse = z.infer<typeof DTOForgeProjectMemberCreateResponse>;
+export type DTOForgeProjectMemberUpdateResponse = z.infer<typeof DTOForgeProjectMemberUpdateResponse>;
+export type DTOForgeProjectMemberRemoveResponse = z.infer<typeof DTOForgeProjectMemberRemoveResponse>;
+export type DTOAddMembersToForgeProject = z.infer<typeof DTOAddMembersToForgeProject>;

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

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

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

@@ -0,0 +1,37 @@
+import { ForgeSection, Id } from "@supernova-studio/model";
+import z from "zod";
+
+const AfterSectionId = z.string().uuid().nullish().optional();
+
+export const DTOForgeSection = ForgeSection;
+
+export const DTOForgeSectionCreateInput = DTOForgeSection.pick({
+  id: true,
+  name: true,
+  childType: true,
+}).extend({
+  afterSectionId: AfterSectionId,
+});
+
+export const DTOForgeSectionUpdateInput = DTOForgeSection.pick({ id: true, name: true });
+
+export const DTOForgeSectionDeleteInput = DTOForgeSection.pick({ id: true }).extend({
+  deleteChildren: z.boolean().default(false),
+});
+
+export const DTOForgeSectionMoveInput = DTOForgeSection.pick({ id: true }).extend({
+  afterSectionId: AfterSectionId,
+});
+
+export const DTOForgeSectionItemMoveInput = z.object({
+  id: Id,
+  sectionId: Id.nullish().optional(), // undefined=stay, null=no section, string=move to section
+  afterId: Id.nullish().optional(), // undefined=end, null=beginning, string=after artifact
+});
+
+export type DTOForgeSection = z.infer<typeof DTOForgeSection>;
+export type DTOForgeSectionCreateInput = z.infer<typeof DTOForgeSectionCreateInput>;
+export type DTOForgeSectionUpdateInput = z.infer<typeof DTOForgeSectionUpdateInput>;
+export type DTOForgeSectionDeleteInput = z.infer<typeof DTOForgeSectionDeleteInput>;
+export type DTOForgeSectionMoveInput = z.infer<typeof DTOForgeSectionMoveInput>;
+export type DTOForgeSectionItemMoveInput = z.infer<typeof DTOForgeSectionItemMoveInput>;

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

@@ -0,0 +1,105 @@
+import { ForgeDefaultProjectRole, ForgeProjectAccessMode, ForgeProjectRole } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOFileReference } from "../files";
+import { DTOForgeProjectArtifactCreateInput } from "./project-artifact";
+import { DTOForgeProjectFeatureCreateInput } from "./project-feature";
+import { DTOCreateForgeProjectInvitation } from "./project-invitation";
+
+export const DTOForgeProjectRole = ForgeProjectRole;
+export const DTOForgeProjectAccessMode = ForgeProjectAccessMode;
+export const DTOForgeProjectDefaultRole = ForgeDefaultProjectRole;
+
+export const DTOForgeProjectDocumentPreview = z.object({
+  id: z.string(),
+  title: z.string(),
+  thumbnail: DTOFileReference.optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export const DTOForgeProjectFeaturePreview = z.object({
+  id: z.string(),
+  name: z.string(),
+  thumbnail: DTOFileReference.optional(),
+  isPublished: z.boolean().optional(),
+  isArchived: z.boolean().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export const DTOForgeProject = z.object({
+  id: z.string(),
+
+  workspaceId: z.string(),
+  projectContextId: z.string(),
+
+  name: z.string(),
+  description: z.string().optional(),
+  instruction: z.string().nullable(),
+  tags: z.array(z.string()).default([]),
+
+  accessMode: DTOForgeProjectAccessMode,
+  defaultRole: DTOForgeProjectDefaultRole,
+
+  isArchived: z.boolean(),
+  emoji: z.string().optional(),
+  tokenThemeSetId: z.string().optional(),
+
+  createdAt: z.coerce.date(),
+  createdByUserId: z.string().optional(),
+  lastUserActivityAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date(),
+
+  documents: DTOForgeProjectDocumentPreview.array(),
+  features: DTOForgeProjectFeaturePreview.array(),
+
+  liveblocksRoomId: z.string().optional(),
+});
+
+export const DTOForgeProjectCreate = DTOForgeProject.pick({
+  name: true,
+  description: true,
+  instruction: true,
+  tags: true,
+  emoji: true,
+  tokenThemeSetId: true,
+}).extend({
+  projectContextId: z.string().optional(),
+
+  membersToInvite: DTOCreateForgeProjectInvitation.array().min(1).optional(),
+  initialFeature: DTOForgeProjectFeatureCreateInput.optional(),
+  initialArtifact: DTOForgeProjectArtifactCreateInput.optional(),
+
+  accessMode: DTOForgeProjectAccessMode.optional(),
+  defaultRole: DTOForgeProjectDefaultRole.optional(),
+});
+
+export const DTOForgeProjectUpdate = DTOForgeProjectCreate.omit({ membersToInvite: true }).partial().extend({
+  id: z.string(),
+  isArchived: z.boolean().optional(),
+});
+
+export const DTOForgeProjectListResponse = z.object({
+  projects: z.array(
+    DTOForgeProject.extend({
+      effectiveRole: DTOForgeProjectRole,
+    })
+  ),
+});
+export const DTOForgeProjectResponse = z.object({
+  project: DTOForgeProject.extend({
+    effectiveRole: DTOForgeProjectRole,
+  }),
+});
+
+export type DTOForgeProjectRole = z.infer<typeof DTOForgeProjectRole>;
+export type DTOForgeProjectAccessMode = z.infer<typeof DTOForgeProjectAccessMode>;
+export type DTOForgeProjectDefaultRole = z.infer<typeof DTOForgeProjectDefaultRole>;
+
+export type DTOForgeProjectDocumentPreview = z.infer<typeof DTOForgeProjectDocumentPreview>;
+export type DTOForgeProjectFeaturePreview = z.infer<typeof DTOForgeProjectFeaturePreview>;
+export type DTOForgeProject = z.infer<typeof DTOForgeProject>;
+export type DTOForgeProjectCreate = z.infer<typeof DTOForgeProjectCreate>;
+export type DTOForgeProjectUpdate = z.infer<typeof DTOForgeProjectUpdate>;
+export type DTOForgeProjectResponse = z.infer<typeof DTOForgeProjectResponse>;
+export type DTOForgeProjectListResponse = z.infer<typeof DTOForgeProjectListResponse>;

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

@@ -0,0 +1,34 @@
+import { ForgeRelation, ForgeRelationType } from "@supernova-studio/model";
+import z from "zod";
+
+export const DTOForgeRelationType = ForgeRelationType;
+
+export const DTOForgeRelation = ForgeRelation;
+
+export const DTOForgeRelationCreate = DTOForgeRelation.omit({ id: true, createdAt: true });
+
+export const DTOForgeRelationDelete = z.object({
+  sourceItemId: z.string().uuid(),
+  targetItemId: z.string().uuid(),
+});
+
+export const DTOForgeRelationListInput = z.object({
+  projectId: z.string(),
+});
+
+export const DTOForgeRelationListResponse = z.object({
+  relations: z.array(DTOForgeRelation),
+});
+
+export const DTOForgeEntity = z.object({
+  id: z.string().uuid(),
+  type: DTOForgeRelationType,
+});
+
+export type DTOForgeRelationType = z.infer<typeof DTOForgeRelationType>;
+export type DTOForgeRelation = z.infer<typeof DTOForgeRelation>;
+export type DTOForgeRelationCreate = z.infer<typeof DTOForgeRelationCreate>;
+export type DTOForgeRelationDelete = z.infer<typeof DTOForgeRelationDelete>;
+export type DTOForgeRelationListInput = z.infer<typeof DTOForgeRelationListInput>;
+export type DTOForgeRelationListResponse = z.infer<typeof DTOForgeRelationListResponse>;
+export type DTOForgeEntity = z.infer<typeof DTOForgeEntity>;

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

@@ -0,0 +1,153 @@
+import {
+  ForgeChatMessage,
+  ForgeChatMessageSender,
+  ForgeChatMessageSenderType,
+  ForgeChatThread,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOForgeChatMessage = ForgeChatMessage;
+export type DTOForgeChatMessage = z.infer<typeof DTOForgeChatMessage>;
+
+export const DTOForgeChatThread = ForgeChatThread;
+export type DTOForgeChatThread = z.infer<typeof DTOForgeChatThread>;
+
+export const DTOForgeChatMessageSenderType = ForgeChatMessageSenderType;
+export type DTOForgeChatMessageSenderType = z.infer<typeof DTOForgeChatMessageSenderType>;
+
+export const DTOForgeChatMessageSender = ForgeChatMessageSender;
+export type DTOForgeChatMessageSender = z.infer<typeof DTOForgeChatMessageSender>;
+
+/**
+ * POST /api/v1/workspaces/{wsId}/forge/chat-threads
+ */
+export const DTOForgeChatThreadCreateInput = z.object({
+  title: z.string().optional(),
+});
+export type DTOForgeChatThreadCreateInput = z.infer<typeof DTOForgeChatThreadCreateInput>;
+
+/**
+ * POST /api/v1/workspaces/{wsId}/forge/threads
+ */
+export const DTOForgeChatThreadCreateResponse = z.object({
+  thread: DTOForgeChatThread,
+});
+export type DTOForgeChatThreadCreateResponse = z.infer<typeof DTOForgeChatThreadCreateResponse>;
+
+/**
+ * PUT /api/v1/workspaces/{wsId}/forge/threads/{threadId}
+ */
+export const DTOForgeChatThreadUpdateInput = z.object({
+  title: z.string(),
+});
+export type DTOForgeChatThreadUpdateInput = z.infer<typeof DTOForgeChatThreadUpdateInput>;
+
+/**
+ * PUT /api/v1/workspaces/{wsId}/forge/threads/{threadId}
+ */
+export const DTOForgeChatThreadUpdateResponse = z.object({
+  thread: DTOForgeChatThread,
+});
+export type DTOForgeChatThreadUpdateResponse = z.infer<typeof DTOForgeChatThreadUpdateResponse>;
+
+/**
+ * DELETE /api/v1/workspaces/{wsId}/forge/threads/{threadId}
+ */
+export const DTOForgeChatThreadDeleteResponse = z.object({
+  success: z.boolean(),
+});
+export type DTOForgeChatThreadDeleteResponse = z.infer<typeof DTOForgeChatThreadDeleteResponse>;
+
+/**
+ * GET /api/v1/workspaces/{wsId}/forge/threads
+ */
+export const DTOForgeChatThreadListQuery = z.object({
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+});
+export type DTOForgeChatThreadListQuery = z.infer<typeof DTOForgeChatThreadListQuery>;
+
+/**
+ * GET /api/v1/workspaces/{wsId}/forge/threads
+ */
+export const DTOForgeChatThreadListResponse = z.object({
+  threads: z.array(DTOForgeChatThread),
+  pagination: z.object({
+    offset: z.number(),
+    limit: z.number(),
+    total: z.number(),
+  }),
+});
+export type DTOForgeChatThreadListResponse = z.infer<typeof DTOForgeChatThreadListResponse>;
+
+/**
+ * POST /api/v1/workspaces/{wsId}/forge/threads/{threadId}/messages
+ */
+export const DTOForgeChatMessageCreateInput = z.object({
+  payload: z.string(),
+  sender: DTOForgeChatMessageSender.optional(),
+});
+
+export type DTOForgeChatMessageCreateInput = z.infer<typeof DTOForgeChatMessageCreateInput>;
+
+/**
+ * POST /api/v1/workspaces/{wsId}/forge/threads/{threadId}/messages
+ */
+export const DTOForgeChatMessageCreateResponse = z.object({
+  message: DTOForgeChatMessage,
+});
+export type DTOForgeChatMessageCreateResponse = z.infer<typeof DTOForgeChatMessageCreateResponse>;
+
+/**
+ * GET /api/v1/workspaces/{wsId}/forge/threads/{threadId}/messages
+ */
+export const DTOForgeChatMessageListQuery = z.object({
+  limit: z
+    .string()
+    .optional()
+    .transform(val => (val ? parseInt(val, 10) : undefined)),
+  offset: z
+    .string()
+    .optional()
+    .transform(val => (val ? parseInt(val, 10) : undefined)),
+});
+
+export type DTOForgeChatMessageListQuery = z.infer<typeof DTOForgeChatMessageListQuery>;
+
+/**
+ * GET /api/v1/workspaces/{wsId}/forge/threads/{threadId}/messages
+ */
+export const DTOForgeChatMessageListResponse = z.object({
+  messages: z.array(DTOForgeChatMessage),
+  totalCount: z.number(),
+  hasMore: z.boolean(),
+});
+
+export type DTOForgeChatMessageListResponse = z.infer<typeof DTOForgeChatMessageListResponse>;
+
+export const DTOForgeChatExportResponse = z.object({
+  csvDownloadUrl: z.string().nullable(),
+});
+export type DTOForgeChatExportResponse = z.infer<typeof DTOForgeChatExportResponse>;
+
+export const DTOForgeChatMessageScoreInput = z.object({
+  messageId: z.string(),
+  name: z.string(),
+  value: z.number(),
+  categoryName: z.string().optional(),
+  reason: z.string().optional(),
+});
+
+export const DTOForgeChatMessageTagInput = z.object({
+  messageId: z.string(),
+  tags: z.array(z.string()),
+});
+
+export const DTOForgeChatMessageScoreRequest = z.object({
+  scores: DTOForgeChatMessageScoreInput.array(),
+  tags: DTOForgeChatMessageTagInput.array().optional().default([]),
+});
+
+export type DTOForgeChatMessageScoreInput = z.infer<typeof DTOForgeChatMessageScoreInput>;
+export type DTOForgeChatMessageTagInput = z.infer<typeof DTOForgeChatMessageTagInput>;
+export type DTOForgeChatMessageScoreRequest = z.infer<typeof DTOForgeChatMessageScoreRequest>;

package/src/api/dto/index.ts

@@ -0,0 +1,25 @@
+export * from "./access-tokens";
+export * from "./aux";
+export * from "./bff";
+export * from "./collections";
+export * from "./design-systems";
+export * from "./design-tokens";
+export * from "./documentation";
+export * from "./elements";
+export * from "./events";
+export * from "./export";
+export * from "./figma-components";
+export * from "./figma-exporter";
+export * from "./files";
+export * from "./forge";
+export * from "./liveblocks";
+export * from "./mcp";
+export * from "./notifications";
+export * from "./portal";
+export * from "./sandboxes";
+export * from "./storybook-sites";
+export * from "./themes";
+export * from "./threads";
+export * from "./trail-events";
+export * from "./users";
+export * from "./workspaces";

package/src/api/dto/liveblocks/auth-response.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const DTOLiveblocksAuthResponse = z.object({
+    token: z.string(),
+})
+
+export type DTOLiveblocksAuthResponse = z.infer<typeof DTOLiveblocksAuthResponse>;

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

@@ -0,0 +1 @@
+export * from "./auth-response";

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

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

package/src/api/dto/mcp/stream.ts

@@ -0,0 +1,17 @@
+import z from "zod";
+
+export const DTOMCPStream = z.object({
+  id: z.string().uuid(),
+  projectFeatureId: z.string().uuid().optional(),
+  projectDocumentId: z.string().uuid().optional(),
+});
+
+export const DTOMCPStreamUpdateInput = DTOMCPStream.omit({ id: true });
+
+export const DTOMCPStreamResponse = z.object({
+  stream: DTOMCPStream,
+});
+
+export type DTOMCPStream = z.infer<typeof DTOMCPStream>;
+export type DTOMCPStreamUpdateInput = z.infer<typeof DTOMCPStreamUpdateInput>;
+export type DTOMCPStreamResponse = z.infer<typeof DTOMCPStreamResponse>;

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

@@ -0,0 +1,2 @@
+export * from "./notifications";
+export * from "./settings";

package/src/api/dto/notifications/notifications.ts

@@ -0,0 +1,65 @@
+import { DTONotificationType } from "./settings";
+import { z } from "zod";
+
+export const DTONotificationChatMentionPayload = z.object({
+  messageAuthorId: z.string(),
+  messageText: z.string(),
+  messageId: z.string(),
+  parentMessageId: z.string().optional(),
+  workspaceId: z.string(),
+  projectId: z.string(),
+  subjectType: z.string(),
+  threadSubjectId: z.string(),
+  subjectName: z.string(),
+});
+
+export const DTONotificationProjectInvitationPayload = z.object({
+  workspaceId: z.string(),
+  projectId: z.string(),
+  projectTitle: z.string(),
+  invitedByUserId: z.string(),
+  invitationRole: z.string(),
+  featureId: z.string().optional(),
+});
+
+export const DTONotificationProjectDocumentCommentPayload = z.object({
+  documentId: z.string(),
+  entityTitle: z.string(),
+  projectId: z.string(),
+  workspaceId: z.string(),
+  threadId: z.string(),
+  commentId: z.string(),
+  commentCreatedAt: z.string(),
+  commentAuthorId: z.string(),
+  commentBody: z.string(),
+});
+
+export const DTONotificationBase = z.object({
+  userId: z.string(),
+  subjectId: z.string(),
+  roomId: z.string().optional(),
+  workspaceId: z.string(),
+});
+
+export const DTONotificationCreateInput = z
+  .discriminatedUnion("type", [
+    z.object({
+      type: z.literal(DTONotificationType.enum.ChatMention),
+      activityData: DTONotificationChatMentionPayload,
+    }),
+    z.object({
+      type: z.literal(DTONotificationType.enum.ProjectInvitation),
+      activityData: DTONotificationProjectInvitationPayload,
+    }),
+    z.object({
+      type: z.literal(DTONotificationType.enum.ProjectDocumentComment),
+      activityData: DTONotificationProjectDocumentCommentPayload,
+    }),
+  ])
+  .and(DTONotificationBase);
+
+export type DTONotificationCreateInput = z.infer<typeof DTONotificationCreateInput>;
+export type DTONotificationChatMentionPayload = z.infer<typeof DTONotificationChatMentionPayload>;
+export type DTONotificationProjectInvitationPayload = z.infer<typeof DTONotificationProjectInvitationPayload>;
+export type DTONotificationProjectDocumentCommentPayload = z.infer<typeof DTONotificationProjectDocumentCommentPayload>;
+export type DTONotificationBase = z.infer<typeof DTONotificationBase>;

package/src/api/dto/notifications/settings.ts

@@ -0,0 +1,10 @@
+import { UserNotificationSettings, NotificationType, NotificationChannel } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOUserNotificationSettings = UserNotificationSettings;
+export const DTONotificationType = NotificationType;
+export const DTONotificationChannel = NotificationChannel;
+
+export type DTOUserNotificationSettings = z.infer<typeof DTOUserNotificationSettings>;
+export type DTONotificationType = z.infer<typeof DTONotificationType>;
+export type DTONotificationChannel = z.infer<typeof DTONotificationChannel>;

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

@@ -0,0 +1 @@
+export * from "./portal-settings";