@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/forge/project-context-feedback.ts

@@ -0,0 +1,141 @@
+import { DTOObjectMetadata } from "../aux"
+
+import { z } from "zod"
+
+export const DTOForgeProjectContextFeedbackSentiment = z.enum([
+  "Positive",
+  "Neutral",
+  "Negative",
+  "Aggressive",
+])
+export const DTOForgeProjectContextFeedbackState = z.enum([
+  "Resolved",
+  "Unresolved",
+])
+export const DTOForgeProjectContextFeedbackCategory = z.enum([
+  "MissingInformation",
+  "Incorrect",
+  "Output",
+  "WrongSource",
+])
+
+export const DTOForgeProjectContextFeedback = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string(),
+  contextId: z.string(),
+  createdByUserId: z.string().optional(),
+  createdAt: z.coerce.date(),
+  message: z
+    .string()
+    .describe(
+      "A concise human-readable summary of the feedback being collected."
+    ),
+  description: z
+    .string()
+    .optional()
+    .describe(
+      "Optional additional details that expand on the feedback summary."
+    ),
+  conversation: z
+    .array(z.string())
+    .describe(
+      "Ordered conversation excerpts that provide context for the feedback. Each item should be one message."
+    ),
+  sentiment: DTOForgeProjectContextFeedbackSentiment.describe(
+    "Overall sentiment of the feedback. Use Positive, Neutral, Negative, or Aggressive."
+  ),
+  state: DTOForgeProjectContextFeedbackState,
+  category: DTOForgeProjectContextFeedbackCategory,
+  llm: z
+    .object({
+      model: z
+        .string()
+        .describe(
+          "The LLM model name that generated or participated in the conversation."
+        ),
+      provider: z.string().describe("The LLM provider name."),
+    })
+    .describe("Information about the LLM associated with this feedback."),
+  metadata: DTOObjectMetadata.optional(),
+})
+
+export const DTOForgeProjectContextFeedbackCreatePayload =
+  DTOForgeProjectContextFeedback.pick({
+    contextId: true,
+    message: true,
+    description: true,
+    conversation: true,
+    sentiment: true,
+    category: true,
+    metadata: true,
+    llm: true,
+  })
+
+export const DTOForgeProjectContextFeedbackListQuery = z
+  .object({
+    contextId: z.string().optional(),
+    workspaceId: z.string().optional(),
+    designSystemId: z.string().optional(),
+  })
+  .refine(
+    (query) =>
+      Boolean(query.contextId) ||
+      Boolean(query.workspaceId) ||
+      Boolean(query.designSystemId),
+    "At least one of contextId, workspaceId, or designSystemId is required."
+  )
+
+export const DTOForgeProjectContextFeedbackDeletePayload = z.object({
+  id: z.union([z.string(), z.array(z.string())]),
+})
+
+export const DTOForgeProjectContextFeedbackUpdatePayload = z.object({
+  id: z.string(),
+  state: DTOForgeProjectContextFeedbackState,
+})
+
+export const DTOForgeProjectContextFeedbackResponse = z.object({
+  feedback: DTOForgeProjectContextFeedback,
+})
+
+export const DTOForgeProjectContextFeedbackListResponse = z.object({
+  feedback: z.array(DTOForgeProjectContextFeedback),
+})
+
+export const DTOForgeProjectContextFeedbackDeleteResponse = z.object({
+  ok: z.literal(true),
+})
+
+export type DTOForgeProjectContextFeedbackSentiment = z.infer<
+  typeof DTOForgeProjectContextFeedbackSentiment
+>
+export type DTOForgeProjectContextFeedbackState = z.infer<
+  typeof DTOForgeProjectContextFeedbackState
+>
+export type DTOForgeProjectContextFeedbackCategory = z.infer<
+  typeof DTOForgeProjectContextFeedbackCategory
+>
+export type DTOForgeProjectContextFeedback = z.infer<
+  typeof DTOForgeProjectContextFeedback
+>
+export type DTOForgeProjectContextFeedbackCreatePayload = z.infer<
+  typeof DTOForgeProjectContextFeedbackCreatePayload
+>
+export type DTOForgeProjectContextFeedbackListQuery = z.infer<
+  typeof DTOForgeProjectContextFeedbackListQuery
+>
+export type DTOForgeProjectContextFeedbackDeletePayload = z.infer<
+  typeof DTOForgeProjectContextFeedbackDeletePayload
+>
+export type DTOForgeProjectContextFeedbackUpdatePayload = z.infer<
+  typeof DTOForgeProjectContextFeedbackUpdatePayload
+>
+export type DTOForgeProjectContextFeedbackResponse = z.infer<
+  typeof DTOForgeProjectContextFeedbackResponse
+>
+export type DTOForgeProjectContextFeedbackListResponse = z.infer<
+  typeof DTOForgeProjectContextFeedbackListResponse
+>
+export type DTOForgeProjectContextFeedbackDeleteResponse = z.infer<
+  typeof DTOForgeProjectContextFeedbackDeleteResponse
+>

package/src/api/dto/forge/project-context-override.ts

@@ -0,0 +1,41 @@
+import z from "zod";
+import { DTOForgeProjectContextV2, DTOForgeProjectTheme } from "./project-context-v2";
+
+export const DTOProjectContextOverride = z.object({
+  projectId: z.string(),
+  theme: DTOForgeProjectTheme.partial(),
+  themePreset: z.string().optional(),
+});
+
+export const DTOProjectContextOverrideInput = z.object({
+  updateSharedContext: z.boolean().optional(),
+  theme: DTOForgeProjectTheme.partial(),
+  themePreset: z.string().optional(),
+});
+
+// TS7056 workaround. DTOForgeProjectContextV2 embeds the recursive scope tree
+// and appears twice here, so a whole-composite `z.infer<...>` would expand both
+// copies inline and overflow the .d.ts emit limit. The cast keeps `.parse()`
+// typed via the manual alias below — runtime validation is unchanged.
+//
+// Alternatives ruled out:
+//   - `z.ZodType<X>` annotation → `.nullish()` input/output variance error
+//   - `z.lazy(() => DTOForgeProjectContextV2)` → same variance error
+//   - `z.ZodTypeAny` annotation → consumers lose `.parse()` typing
+export const DTOProjectContextOverrideResponse = z.object({
+  override: DTOProjectContextOverride,
+  originalContext: DTOForgeProjectContextV2,
+  resolvedContext: DTOForgeProjectContextV2,
+}) as unknown as z.ZodType<DTOProjectContextOverrideResponse>;
+
+export type DTOProjectContextOverride = z.infer<typeof DTOProjectContextOverride>;
+export type DTOProjectContextOverrideInput = z.infer<typeof DTOProjectContextOverrideInput>;
+// Manual definition (not `z.infer<typeof DTOProjectContextOverrideResponse>`)
+// for the same TS7056 reason — see comment on the schema above. Field-level
+// `z.infer<typeof DTOForgeProjectContextV2>` is fine because TS emits it as a
+// name reference, not an inline expansion.
+export type DTOProjectContextOverrideResponse = {
+  override: DTOProjectContextOverride;
+  originalContext: z.infer<typeof DTOForgeProjectContextV2>;
+  resolvedContext: z.infer<typeof DTOForgeProjectContextV2>;
+};

package/src/api/dto/forge/project-context-scope.ts

@@ -0,0 +1,23 @@
+import {
+  ForgeProjectContextMcpUrlSlug,
+  ForgeProjectContextScope,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+const MAX_SCOPE_BYTES = 1024 * 1024;
+
+// Adds a 1MB wire-format cap on top of the model schema.
+export const DTOForgeProjectContextScope = ForgeProjectContextScope.superRefine((scope, ctx) => {
+  const size = new TextEncoder().encode(JSON.stringify(scope)).length;
+  if (size > MAX_SCOPE_BYTES) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Project context scope must be 1MB or smaller.",
+    });
+  }
+});
+
+export type DTOForgeProjectContextScope = ForgeProjectContextScope;
+
+export const DTOForgeMcpUrlSlug = ForgeProjectContextMcpUrlSlug;
+export type DTOForgeMcpUrlSlug = ForgeProjectContextMcpUrlSlug;

package/src/api/dto/forge/project-context-v2.ts

@@ -0,0 +1,228 @@
+import {
+  BorderRadiusTokenData,
+  ColorTokenData,
+  FontFamilyTokenData,
+  FontSizeTokenData,
+  FontWeightTokenData,
+  LineHeightTokenData,
+  ShadowTokenData,
+  SpaceTokenData,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { zodQueryBoolean } from "../../../utils/query";
+import { DTOObjectMetadata } from "../aux";
+import { DTOFileReference } from "../files/files";
+import { DTOForgeMcpUrlSlug, DTOForgeProjectContextScope } from "./project-context-scope";
+
+export const DTOForgeComponentSetTypeV2 = z.enum(["Shadcn"]);
+export const DTOForgeComponentSet = z.object({
+  type: DTOForgeComponentSetTypeV2,
+});
+
+export const DTOForgeIconSetTypeV2 = z.enum(["Phosphor", "Lucide", "Tabler"]);
+export const DTOForgeThemeKnownPreset = z.enum(["Default", "Airbnb", "Spotify", "Windows98"]);
+
+export const DTOForgeIconSet = z.object({
+  type: DTOForgeIconSetTypeV2,
+  variant: z.string().optional(),
+});
+
+export const DTOForgeTokenThemeSet = z.object({
+  id: z.string(),
+  name: z.string(),
+  tokenThemeIds: z.array(z.string()),
+});
+
+export const DTOForgeProjectTheme = z.object({
+  // Colors
+  background: ColorTokenData,
+  foreground: ColorTokenData,
+  card: ColorTokenData,
+  cardForeground: ColorTokenData,
+  popover: ColorTokenData,
+  popoverForeground: ColorTokenData,
+  primary: ColorTokenData,
+  primaryForeground: ColorTokenData,
+  secondary: ColorTokenData,
+  secondaryForeground: ColorTokenData,
+  muted: ColorTokenData,
+  mutedForeground: ColorTokenData,
+  accent: ColorTokenData,
+  accentForeground: ColorTokenData,
+  destructive: ColorTokenData,
+  border: ColorTokenData,
+  input: ColorTokenData,
+  ring: ColorTokenData,
+  chart1: ColorTokenData,
+  chart2: ColorTokenData,
+  chart3: ColorTokenData,
+  chart4: ColorTokenData,
+  chart5: ColorTokenData,
+  sidebar: ColorTokenData,
+  sidebarForeground: ColorTokenData,
+  sidebarPrimary: ColorTokenData,
+  sidebarPrimaryForeground: ColorTokenData,
+  sidebarAccent: ColorTokenData,
+  sidebarAccentForeground: ColorTokenData,
+  sidebarBorder: ColorTokenData,
+  sidebarRing: ColorTokenData,
+
+  // Font family
+  fontFamily: FontFamilyTokenData,
+
+  // Font sizes
+  textXs: FontSizeTokenData,
+  textSm: FontSizeTokenData,
+  textBase: FontSizeTokenData,
+  textLg: FontSizeTokenData,
+  textXl: FontSizeTokenData,
+  text2xl: FontSizeTokenData,
+  text3xl: FontSizeTokenData,
+  text4xl: FontSizeTokenData,
+  text5xl: FontSizeTokenData,
+  text6xl: FontSizeTokenData,
+  text7xl: FontSizeTokenData,
+  text8xl: FontSizeTokenData,
+  text9xl: FontSizeTokenData,
+
+  // Line heights
+  textXsLineHeight: LineHeightTokenData,
+  textSmLineHeight: LineHeightTokenData,
+  textBaseLineHeight: LineHeightTokenData,
+  textLgLineHeight: LineHeightTokenData,
+  textXlLineHeight: LineHeightTokenData,
+  text2xlLineHeight: LineHeightTokenData,
+  text3xlLineHeight: LineHeightTokenData,
+  text4xlLineHeight: LineHeightTokenData,
+  text5xlLineHeight: LineHeightTokenData,
+  text6xlLineHeight: LineHeightTokenData,
+  text7xlLineHeight: LineHeightTokenData,
+  text8xlLineHeight: LineHeightTokenData,
+  text9xlLineHeight: LineHeightTokenData,
+
+  // Font weights
+  fontWeightThin: FontWeightTokenData,
+  fontWeightExtralight: FontWeightTokenData,
+  fontWeightLight: FontWeightTokenData,
+  fontWeightNormal: FontWeightTokenData,
+  fontWeightMedium: FontWeightTokenData,
+  fontWeightSemibold: FontWeightTokenData,
+  fontWeightBold: FontWeightTokenData,
+  fontWeightExtrabold: FontWeightTokenData,
+  fontWeightBlack: FontWeightTokenData,
+
+  // Other dimensions
+  radius: BorderRadiusTokenData,
+  spacing: SpaceTokenData,
+
+  // Shadows
+  shadow2xs: ShadowTokenData,
+  shadowXs: ShadowTokenData,
+  shadowSm: ShadowTokenData,
+  shadowMd: ShadowTokenData,
+  shadowLg: ShadowTokenData,
+  shadowXl: ShadowTokenData,
+  shadow2xl: ShadowTokenData,
+});
+
+export const DTOForgeProjectContextV2 = z.object({
+  id: z.string(),
+  name: z.string(),
+  workspaceId: z.string(),
+  designSystemId: z.string().optional(),
+  brandId: z.string().optional(),
+  defaultTokenThemeSetId: z.string().optional(),
+  description: z.string().optional(),
+  productContext: z.string().optional(),
+  additionalContext: z.string().optional(),
+  isArchived: z.boolean(),
+  isAllowedInPortal: z.boolean(),
+  isLibraryDismissed: z.boolean().optional(),
+  themePreset: z.string().optional(),
+  tokenThemeSets: z.array(DTOForgeTokenThemeSet).optional(),
+  scope: DTOForgeProjectContextScope.nullish(),
+  mcpUrlSlug: DTOForgeMcpUrlSlug.nullish(),
+  metadata: DTOObjectMetadata.optional(),
+  componentSet: DTOForgeComponentSet,
+  iconSet: DTOForgeIconSet,
+  theme: DTOForgeProjectTheme,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  thumbnail: DTOFileReference.optional(),
+
+  sandboxTemplate: z
+    .object({
+      id: z.string(),
+      version: z.string(),
+    })
+    .optional(),
+});
+
+export const DTOForgeProjectContextCreateV2 = DTOForgeProjectContextV2.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+  isArchived: true,
+  thumbnail: true,
+})
+  .extend({
+    // Optional on create: FE may pass an explicit value, otherwise the server
+    // derives it (true when a sandbox template or component library is provided, else false).
+    isAllowedInPortal: z.boolean().optional(),
+    thumbnailFileId: z.string().optional(),
+    theme: DTOForgeProjectTheme.optional(),
+    iconSet: DTOForgeIconSet.optional(),
+    componentSet: DTOForgeComponentSet.optional(),
+  })
+  .superRefine((input, ctx) => {
+    // If FE sets isAllowedInPortal to false => we don't care about templates/component lib
+    if (input.isAllowedInPortal === false) return;
+
+    const hasDefaultTemplateFields = input.theme && input.iconSet && input.componentSet;
+    const hasCustomTemplateFields = input.sandboxTemplate;
+
+    if (hasDefaultTemplateFields || hasCustomTemplateFields) return;
+
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message:
+        "Either the setup fields for default template (theme, iconSet, componentSet) or a sandbox template field (sandboxTemplate) must be provided.",
+      path: ["theme", "iconSet", "componentSet", "sandboxTemplate"],
+    });
+  });
+
+export const DTOForgeProjectContextUpdateV2 = DTOForgeProjectContextV2.omit({
+  id: true,
+  workspaceId: true,
+  // designSystemId + brandId are immutable after create. Changing them on an
+  // existing context would orphan stored scope (token/page ids reference the
+  // original DS/brand). To re-target, create a new context.
+  designSystemId: true,
+  brandId: true,
+  createdAt: true,
+  updatedAt: true,
+  thumbnail: true,
+})
+  .partial()
+  .extend({
+    thumbnailFileId: z.string().nullish(),
+  });
+
+export const DTOForgeProjectContextResponseV2 = z.object({ context: DTOForgeProjectContextV2 });
+export const DTOForgeProjectContextListQueryV2 = z.object({
+  workspaceId: z.string(),
+  isArchived: zodQueryBoolean(),
+});
+export const DTOForgeProjectContextListResponseV2 = z.object({ contexts: z.array(DTOForgeProjectContextV2) });
+
+export type DTOForgeTokenThemeSet = z.infer<typeof DTOForgeTokenThemeSet>;
+export type DTOForgeProjectContextV2 = z.infer<typeof DTOForgeProjectContextV2>;
+export type DTOForgeThemeKnownPreset = z.infer<typeof DTOForgeThemeKnownPreset>;
+export type DTOForgeProjectContextCreateV2 = z.infer<typeof DTOForgeProjectContextCreateV2>;
+export type DTOForgeProjectContextUpdateV2 = z.infer<typeof DTOForgeProjectContextUpdateV2>;
+export type DTOForgeIconSetTypeV2 = z.infer<typeof DTOForgeIconSetTypeV2>;
+export type DTOForgeComponentSetTypeV2 = z.infer<typeof DTOForgeComponentSetTypeV2>;
+export type DTOForgeProjectContextResponseV2 = z.infer<typeof DTOForgeProjectContextResponseV2>;
+export type DTOForgeProjectContextListQueryV2 = z.infer<typeof DTOForgeProjectContextListQueryV2>;
+export type DTOForgeProjectContextListResponseV2 = z.infer<typeof DTOForgeProjectContextListResponseV2>;
+export type DTOForgeProjectTheme = z.infer<typeof DTOForgeProjectTheme>;

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

@@ -0,0 +1,72 @@
+import { NpmRegistryConfig } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTONpmRegistryConfig } from "../workspaces";
+
+/**
+ * @deprecated
+ */
+export const DTOForgeProjectContext = z.object({
+  definition: z.string(),
+  dependencies: z.array(
+    z.object({
+      packageName: z.string(),
+      type: z.literal("npm"),
+      version: z.string().default("latest"),
+    })
+  ),
+  designSystemId: z.string(),
+  id: z.string(),
+  meta: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+  }),
+  name: z.string(),
+  npmProxySettings: DTONpmRegistryConfig.optional(),
+  platform: z.enum(["React", "Vue", "Angular"]),
+  styling: z.enum(["CSS", "Tailwind"]),
+
+  tailwindConfig: z
+    .object({
+      content: z.string(),
+      version: z.string(),
+    })
+    .optional(),
+
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  workspaceId: z.string(),
+});
+
+export const DTOCreateForgeProjectContext = DTOForgeProjectContext.pick({
+  definition: true,
+  name: true,
+  meta: true,
+  designSystemId: true,
+  platform: true,
+  dependencies: true,
+  tailwindConfig: true,
+  styling: true,
+}).extend({ npmProxySettings: DTONpmRegistryConfig });
+
+export const DTOUpdateForgeProjectContext = DTOCreateForgeProjectContext.partial().extend({ id: z.string() });
+
+export const DTOForgeProjectContextGetResponse = z.object({ context: DTOForgeProjectContext });
+
+export const DTOForgeProjectContextListResponse = z.object({ contexts: z.array(DTOForgeProjectContext) });
+
+export const DTOForgeProjectContextCreateResponse = z.object({ context: DTOForgeProjectContext });
+
+export const DTOForgeProjectContextUpdateResponse = z.object({ context: DTOForgeProjectContext });
+
+export const DTOForgeProjectContextRemoveResponse = z.object({
+  ok: z.literal(true),
+});
+
+export type DTOForgeProjectContext = z.infer<typeof DTOForgeProjectContext>;
+export type DTOCreateForgeProjectContext = z.infer<typeof DTOCreateForgeProjectContext>;
+export type DTOUpdateForgeProjectContext = z.infer<typeof DTOUpdateForgeProjectContext>;
+export type DTOForgeProjectContextGetResponse = z.infer<typeof DTOForgeProjectContextGetResponse>;
+export type DTOForgeProjectContextListResponse = z.infer<typeof DTOForgeProjectContextListResponse>;
+export type DTOForgeProjectContextCreateResponse = z.infer<typeof DTOForgeProjectContextCreateResponse>;
+export type DTOForgeProjectContextUpdateResponse = z.infer<typeof DTOForgeProjectContextUpdateResponse>;
+export type DTOForgeProjectContextRemoveResponse = z.infer<typeof DTOForgeProjectContextRemoveResponse>;

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

@@ -0,0 +1,86 @@
+import { FeaturePublishedState, Id, ProjectFeature, ProjectFeatureStatus } from "@supernova-studio/model";
+import z from "zod";
+import { DTOThreadMessageCreateInput } from "../threads";
+import { DTOForgeSectionItemMoveInput } from "./project-section";
+
+export const DTOFeaturePublishedStateUpdateInput = FeaturePublishedState.pick({
+  iterationId: true,
+  hideSupernovaUI: true,
+  visibility: true,
+});
+export const DTOForgeProjectFeature = ProjectFeature;
+
+export const DTOForgeProjectPublishedFeature = z.object({
+  featureName: z.string(),
+  iterationName: z.string(),
+  hideSupernovaUI: z.boolean(),
+  thumbnailUrl: z.string().optional(),
+  staticPreviewUrl: z.string().optional(),
+
+  // These are only included when authenticated user has access to the project (for both public & private published features)
+  projectId: z.string().optional(),
+  projectName: z.string().optional(),
+  workspaceId: z.string().optional(),
+});
+
+export const DTOForgeProjectPublishedFeatureGetResponse = z.object({
+  publishedFeature: DTOForgeProjectPublishedFeature,
+});
+
+export const DTOForgeProjectFeatureListResponse = z.object({
+  features: DTOForgeProjectFeature.array(),
+});
+
+export const DTOForgeProjectFeatureGetResponse = z.object({
+  feature: DTOForgeProjectFeature,
+});
+
+export const DTOForgeProjectFeatureCreateInput = z.object({
+  id: Id,
+  name: z.string().optional(),
+  description: z.string(),
+  sectionId: Id.optional(),
+  afterFeatureId: Id.nullable().optional(),
+  initialMessage: DTOThreadMessageCreateInput,
+});
+
+export const DTOForgeProjectFeatureUpdateInput = z.object({
+  id: Id,
+  name: z.string().optional(),
+  description: z.string().optional(),
+  isArchived: z.boolean().optional(),
+  status: ProjectFeatureStatus.optional(),
+
+  /**
+   * Sending null will result in feature unpublish
+   */
+  publishedState: DTOFeaturePublishedStateUpdateInput.nullish(),
+});
+
+export const DTOForgeProjectFeatureDeleteInput = z.object({
+  id: Id,
+});
+
+export const DTOForgeProjectFeatureGetByIdParam = z.object({
+  id: Id,
+});
+
+export const DTOFeatureArtifactListQuery = z.object({
+  messageId: z.string().optional(),
+  iterationId: z.string().optional(),
+});
+
+export const DTOForgeProjectFeatureMoveInput = DTOForgeSectionItemMoveInput;
+
+export type DTOForgeProjectFeature = z.infer<typeof DTOForgeProjectFeature>;
+export type DTOForgeProjectFeatureListResponse = z.infer<typeof DTOForgeProjectFeatureListResponse>;
+export type DTOForgeProjectFeatureCreateInput = z.infer<typeof DTOForgeProjectFeatureCreateInput>;
+export type DTOForgeProjectFeatureUpdateInput = z.infer<typeof DTOForgeProjectFeatureUpdateInput>;
+export type DTOForgeProjectFeatureDeleteInput = z.infer<typeof DTOForgeProjectFeatureDeleteInput>;
+export type DTOForgeProjectFeatureGetByIdParam = z.infer<typeof DTOForgeProjectFeatureGetByIdParam>;
+export type DTOForgeProjectFeatureMoveInput = z.infer<typeof DTOForgeProjectFeatureMoveInput>;
+export type DTOForgeProjectFeatureGetResponse = z.infer<typeof DTOForgeProjectFeatureGetResponse>;
+export type DTOForgeProjectPublishedFeature = z.infer<typeof DTOForgeProjectPublishedFeature>;
+export type DTOForgeProjectPublishedFeatureGetResponse = z.infer<typeof DTOForgeProjectPublishedFeatureGetResponse>;
+export type DTOFeaturePublishedStateUpdateInput = z.infer<typeof DTOFeaturePublishedStateUpdateInput>;
+export type DTOFeatureArtifactListQuery = z.infer<typeof DTOFeatureArtifactListQuery>;

package/src/api/dto/forge/project-figma-node.ts

@@ -0,0 +1,9 @@
+import { ForgeProjectFigmaNode, ForgeProjectFigmaNodeRenderInput } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOForgeProjectFigmaNode = ForgeProjectFigmaNode;
+
+export const DTOForgeProjectFigmaNodeRenderInput = ForgeProjectFigmaNodeRenderInput;
+
+export type DTOForgeProjectFigmaNode = z.infer<typeof DTOForgeProjectFigmaNode>;
+export type DTOForgeProjectFigmaNodeRenderInput = z.infer<typeof DTOForgeProjectFigmaNodeRenderInput>;

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

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+export const DTOForgeProjectFile = z.object({
+  id: z.string(),
+  name: z.string(),
+  checksum: z.string(),
+  pendingUpload: z.boolean().optional(),
+  url: z.string(),
+  size: z.number(),
+});
+
+export const DTOForgeProjectFileListResponse = z.object({
+  files: z.array(DTOForgeProjectFile),
+});
+
+export const DTOForgeProjectFileUploadPayloadItem = z.object({
+  size: z.number(),
+  name: z.string(),
+  checksum: z.string(),
+});
+
+export const DTOForgeProjectFileUploadPayload = z.object({
+  files: z.array(DTOForgeProjectFileUploadPayloadItem),
+});
+
+export const DTOForgeProjectFileUploadResponse = z.object({
+  files: z.array(DTOForgeProjectFile),
+  uploadUrls: z.array(
+    z.object({
+      fileId: z.string(),
+      uploadUrl: z.string(),
+    })
+  ),
+});
+
+export const DTOForgeProjectFileUploadFinalizePayload = z.object({
+  fileIds: z.array(z.string()),
+});
+
+export const DTOForgeProjectFileUploadFinalizeResponse = z.object({ ok: z.literal(true) });
+
+export type DTOForgeProjectFile = z.infer<typeof DTOForgeProjectFile>;
+export type DTOForgeProjectFileListResponse = z.infer<typeof DTOForgeProjectFileListResponse>;
+export type DTOForgeProjectFileUploadPayloadItem = z.infer<typeof DTOForgeProjectFileUploadPayloadItem>;
+export type DTOForgeProjectFileUploadPayload = z.infer<typeof DTOForgeProjectFileUploadPayload>;
+export type DTOForgeProjectFileUploadResponse = z.infer<typeof DTOForgeProjectFileUploadResponse>;
+export type DTOForgeProjectFileUploadFinalizePayload = z.infer<typeof DTOForgeProjectFileUploadFinalizePayload>;
+export type DTOForgeProjectFileUploadFinalizeResponse = z.infer<typeof DTOForgeProjectFileUploadFinalizeResponse>;