@supernova-studio/client 1.96.6 → 1.96.7

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

@@ -0,0 +1,117 @@
+import z from "zod";
+import { DTOFileReference } from "../files";
+
+//
+// Entity
+//
+
+export const DTOForgeFigmaNodeState = z.enum(["Optimizing", "Success", "Failed"]);
+
+export const DTOForgeFigmaNodeConversionVersion = z.enum([
+  "V1",
+  "V2",
+  "V3",
+  "V4",
+  "V5",
+  "V6",
+  "V7",
+  "V8",
+  "V9",
+  "V10",
+  "V11",
+  "V12",
+]);
+
+export const ForgeFigmaNodeLatestVersion = DTOForgeFigmaNodeConversionVersion.enum.V12;
+
+export const DTOForgeFigmaNodeOrigin = z.object({
+  /**
+   * Figma file ID that was passed into the create request as a part of the Figma node URL
+   */
+  fileId: z.string(),
+
+  fileName: z.string(),
+
+  /**
+   * Timestamp of the last edit to the file, can be used for reusing nodes
+   * if the file has not changed since
+   */
+  fileLastEditedAt: z.string(),
+
+  /**
+   * Figma node ID that was passed into the create request as a part of the Figma node URL
+   */
+  nodeId: z.string(),
+
+  nodeName: z.string(),
+});
+
+export const DTOForgeFigmaNode = z.object({
+  id: z.string().uuid(),
+
+  state: DTOForgeFigmaNodeState,
+
+  /**
+   * Describes where the frame is coming from
+   */
+  origin: DTOForgeFigmaNodeOrigin,
+
+  /**
+   * An image of the node rendered by Figma using render image API.
+   */
+  thumbnail: DTOFileReference,
+
+  /**
+   * JSON representation of the Figma node, downloaded from Figma API
+   */
+  json: DTOFileReference,
+
+  /**
+   * HTML representation of the Figma node, converted from JSON
+   */
+  html: DTOFileReference,
+
+  /**
+   * @deprecated - Optimizing phase was removed, this field is no longer available.
+   *
+   * Code representation of the Figma node. Code gets produced during "Optimizing" phase,
+   * it's available when the node reaches "Success" state.
+   */
+  code: DTOFileReference.optional(),
+});
+
+export type DTOForgeFigmaNodeOrigin = z.infer<typeof DTOForgeFigmaNodeOrigin>;
+export type DTOForgeFigmaNodeState = z.infer<typeof DTOForgeFigmaNodeState>;
+export type DTOForgeFigmaNode = z.infer<typeof DTOForgeFigmaNode>;
+
+//
+// Payloads
+//
+
+export const DTOForgeFigmaNodeCreateRequest = z.object({
+  /**
+   * Workspace ID that will own the node. Figma API keys will be used from this workspace.
+   */
+  workspaceId: z.string(),
+
+  /**
+   * URL that points to a Figma file and a node within the file.
+   * Example: https://www.figma.com/design/If4RI8SKtO2azWx8ytfp03/Child-File?node-id=0-1
+   *
+   * Note that the file must contain `node-id` query param, otherwise the request will be rejected
+   */
+  figmaNodeUrl: z.string().url(),
+});
+
+export const DTOForgeFigmaNodeResponse = z.object({
+  figmaNode: DTOForgeFigmaNode,
+});
+
+export const DTOForgeFigmaNodeValidateResponse = z.object({
+  isValid: z.boolean(),
+});
+
+export type DTOForgeFigmaNodeCreateRequest = z.infer<typeof DTOForgeFigmaNodeCreateRequest>;
+export type DTOForgeFigmaNodeResponse = z.infer<typeof DTOForgeFigmaNodeResponse>;
+export type DTOForgeFigmaNodeValidateResponse = z.infer<typeof DTOForgeFigmaNodeValidateResponse>;
+export type DTOForgeFigmaNodeConversionVersion = z.infer<typeof DTOForgeFigmaNodeConversionVersion>;

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

@@ -0,0 +1,28 @@
+export * from "./agent";
+export * from "./artifact";
+export * from "./feature-messages";
+export * from "./feature-room";
+export * from "./figma-node";
+export * from "./iteration-message-old";
+export * from "./knowledge-item";
+export * from "./memory";
+export * from "./participant";
+export * from "./project-action";
+export * from "./project-artifact-room";
+export * from "./project-artifact";
+export * from "./project-context-feedback";
+export * from "./project-context-override";
+export * from "./project-context-scope";
+export * from "./project-context-v2";
+export * from "./project-context";
+export * from "./project-feature";
+export * from "./project-figma-node";
+export * from "./project-file";
+export * from "./project-invitation";
+export * from "./project-iteration-old";
+export * from "./project-member";
+export * from "./project-room";
+export * from "./project-section";
+export * from "./project";
+export * from "./relation";
+export * from "./threads";

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

@@ -0,0 +1,43 @@
+import { ForgeIterationMessage } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOForgeParticipant } from "./participant";
+
+export const DTOForgeIterationMessage = ForgeIterationMessage.omit({ participant: true }).extend({
+  participant: DTOForgeParticipant,
+});
+
+export const DTOCreateForgeIterationMessage = DTOForgeIterationMessage.omit({
+  projectIterationId: true,
+  participant: true,
+});
+
+export const DTOGetForgeIterationMessageResponse = z.object({
+  message: DTOForgeIterationMessage.nullable(),
+});
+
+export const DTOForgeIterationMessagesListResponse = z.object({
+  messages: z.array(DTOForgeIterationMessage),
+});
+
+export const DTOUpdateForgeIterationMessage = DTOCreateForgeIterationMessage.extend({ id: z.string() });
+
+export const DTOCreateForgeIterationMessageResponse = z.object({
+  message: DTOForgeIterationMessage,
+});
+
+export const DTOUpdateForgeIterationMessageResponse = z.object({
+  message: DTOForgeIterationMessage.nullable(),
+});
+
+export const DTODeleteForgeIterationMessageResponse = z.object({
+  ok: z.literal(true),
+});
+
+export type DTOForgeIterationMessage = z.infer<typeof DTOForgeIterationMessage>;
+export type DTOGetForgeIterationMessageResponse = z.infer<typeof DTOGetForgeIterationMessageResponse>;
+export type DTOForgeIterationMessagesListResponse = z.infer<typeof DTOForgeIterationMessagesListResponse>;
+export type DTOCreateForgeIterationMessage = z.infer<typeof DTOCreateForgeIterationMessage>;
+export type DTOUpdateForgeIterationMessage = z.infer<typeof DTOUpdateForgeIterationMessage>;
+export type DTOCreateForgeIterationMessageResponse = z.infer<typeof DTOCreateForgeIterationMessageResponse>;
+export type DTOUpdateForgeIterationMessageResponse = z.infer<typeof DTOUpdateForgeIterationMessageResponse>;
+export type DTODeleteForgeIterationMessageResponse = z.infer<typeof DTODeleteForgeIterationMessageResponse>;

package/src/api/dto/forge/knowledge-item.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { DTOFileReference } from "../files/files";
+
+export const DTOKnowledgeItemType = z.enum(["File", "Skill"]);
+
+const DTOKnowledgeItemWritableFields = z.object({
+  path: z.string(),
+  description: z.string().max(1024),
+  type: DTOKnowledgeItemType,
+  fileId: z.string(),
+  parentItemId: z.string().nullable().optional(),
+});
+
+export const DTOKnowledgeItem = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  createdByUserId: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  path: z.string(),
+  description: z.string().max(1024),
+  type: DTOKnowledgeItemType,
+  file: DTOFileReference.extend({
+    size: z.number(),
+  }),
+  parentItemId: z.string().nullable(),
+});
+
+export type DTOKnowledgeItemCreatePayload = z.infer<typeof DTOKnowledgeItemWritableFields> & {
+  childrenItems?: DTOKnowledgeItemCreatePayload[];
+};
+
+export const DTOKnowledgeItemCreatePayload: z.ZodType<DTOKnowledgeItemCreatePayload> =
+  DTOKnowledgeItemWritableFields.extend({
+    childrenItems: z.lazy(() => z.array(DTOKnowledgeItemCreatePayload)).optional(),
+  });
+
+export const DTOKnowledgeItemUpdatePayload = DTOKnowledgeItemWritableFields.pick({
+  path: true,
+  description: true,
+  fileId: true,
+  parentItemId: true,
+}).partial();
+
+export const DTOKnowledgeItemDeletePayload = z.object({
+  id: z.union([z.string(), z.array(z.string())]),
+});
+
+export const DTOKnowledgeItemListResponse = z.object({
+  items: z.array(DTOKnowledgeItem),
+});
+
+export const DTOKnowledgeItemResponse = z.object({
+  item: DTOKnowledgeItem,
+});
+
+export const DTOKnowledgeItemDeleteResponse = z.object({
+  deletedIds: z.array(z.string()),
+});
+
+export type DTOKnowledgeItemType = z.infer<typeof DTOKnowledgeItemType>;
+export type DTOKnowledgeItem = z.infer<typeof DTOKnowledgeItem>;
+export type DTOKnowledgeItemUpdatePayload = z.infer<typeof DTOKnowledgeItemUpdatePayload>;
+export type DTOKnowledgeItemDeletePayload = z.infer<typeof DTOKnowledgeItemDeletePayload>;
+export type DTOKnowledgeItemListResponse = z.infer<typeof DTOKnowledgeItemListResponse>;
+export type DTOKnowledgeItemResponse = z.infer<typeof DTOKnowledgeItemResponse>;
+export type DTOKnowledgeItemDeleteResponse = z.infer<typeof DTOKnowledgeItemDeleteResponse>;

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

@@ -0,0 +1,67 @@
+import z from "zod";
+
+export const DTOForgeMemoryEntry = z.object({
+  id: z.string().uuid(),
+  projectId: z.string(),
+  text: z.string(),
+  category: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  metadata: z.record(z.string()).optional(),
+});
+
+/**
+ * Schema that defines a single memory entry create input
+ */
+export const DTOForgeMemoryCreateInput = z.object({
+  projectId: z.string(),
+  text: z.string(),
+  category: z.string(),
+  metadata: z.record(z.string()).optional(),
+});
+
+/**
+ * Schema that defines a single memory entry update input
+ */
+export const DTOForgeMemoryUpdateInput = z.object({
+  id: z.string().uuid(),
+  text: z.string().optional(),
+  category: z.string(),
+  metadata: z.record(z.string()).nullish(),
+});
+
+/**
+ * Schema that defines a single memory entry delete input
+ */
+export const DTOForgeMemoryDeleteInput = z.object({
+  id: z.string().uuid(),
+});
+
+/**
+ * Response containing a list of memory entries (can be empty array)
+ */
+export const DTOForgeMemoryEntryListResponse = z.object({
+  memoryEntries: DTOForgeMemoryEntry.array(),
+});
+
+/**
+ * Response containing a single memory entry
+ */
+export const DTOForgeMemoryEntryResponse = z.object({
+  memoryEntry: DTOForgeMemoryEntry,
+});
+
+/**
+ * Properties used to list memory entries
+ */
+export const DTOForgeMemoryEntryListQuery = z.object({
+  projectId: z.string(),
+});
+
+export type DTOForgeMemoryEntry = z.infer<typeof DTOForgeMemoryEntry>;
+export type DTOForgeMemoryCreateInput = z.infer<typeof DTOForgeMemoryCreateInput>;
+export type DTOForgeMemoryUpdateInput = z.infer<typeof DTOForgeMemoryUpdateInput>;
+export type DTOForgeMemoryDeleteInput = z.infer<typeof DTOForgeMemoryDeleteInput>;
+export type DTOForgeMemoryEntryListResponse = z.infer<typeof DTOForgeMemoryEntryListResponse>;
+export type DTOForgeMemoryEntryResponse = z.infer<typeof DTOForgeMemoryEntryResponse>;
+export type DTOForgeMemoryEntryListQuery = z.infer<typeof DTOForgeMemoryEntryListQuery>;

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

@@ -0,0 +1,44 @@
+import { ForgeParticipant } from "@supernova-studio/model";
+import { DTOForgeAgent } from "./agent";
+import { DTOUser } from "../users";
+import { z } from "zod";
+
+export const DTOForgeParticipant = ForgeParticipant.omit({ agent: true, user: true }).extend({
+  agent: DTOForgeAgent.optional(),
+  user: DTOUser.optional(),
+});
+export const DTOCreateForgeParticipant = DTOForgeParticipant.omit({
+  projectIterationId: true,
+  agent: true,
+  user: true,
+});
+export const DTOUpdateForgeParticipant = DTOCreateForgeParticipant.extend({ id: z.string() });
+
+export const DTOCreateForgeParticipantResponse = z.object({
+  participant: DTOForgeParticipant,
+});
+
+export const DTOUpdateForgeParticipantResponse = z.object({
+  participant: DTOForgeParticipant.nullable(),
+});
+
+export const DTODeleteForgeParticipantResponse = z.object({
+  ok: z.literal(true),
+});
+
+export const DTOForgeParticipantsListResponse = z.object({
+  participants: z.array(DTOForgeParticipant),
+});
+
+export const DTOForgeParticipantGetResponse = z.object({
+  participant: DTOForgeParticipant.nullable(),
+});
+
+export type DTOForgeParticipantsListResponse = z.infer<typeof DTOForgeParticipantsListResponse>;
+export type DTOForgeParticipantGetResponse = z.infer<typeof DTOForgeParticipantGetResponse>;
+export type DTOForgeParticipant = z.infer<typeof DTOForgeParticipant>;
+export type DTOCreateForgeParticipant = z.infer<typeof DTOCreateForgeParticipant>;
+export type DTOUpdateForgeParticipant = z.infer<typeof DTOUpdateForgeParticipant>;
+export type DTOCreateForgeParticipantResponse = z.infer<typeof DTOCreateForgeParticipantResponse>;
+export type DTOUpdateForgeParticipantResponse = z.infer<typeof DTOUpdateForgeParticipantResponse>;
+export type DTODeleteForgeParticipantResponse = z.infer<typeof DTODeleteForgeParticipantResponse>;

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

@@ -0,0 +1,123 @@
+import z from "zod";
+import {
+  DTOForgeProjectArtifactCreateInput,
+  DTOForgeProjectArtifactDeleteInput,
+  DTOForgeProjectArtifactMoveInput,
+  DTOForgeProjectArtifactUpdateInput,
+} from "./project-artifact";
+import {
+  DTOForgeProjectFeatureCreateInput,
+  DTOForgeProjectFeatureDeleteInput,
+  DTOForgeProjectFeatureMoveInput,
+  DTOForgeProjectFeatureUpdateInput,
+} from "./project-feature";
+import {
+  DTOForgeSectionCreateInput,
+  DTOForgeSectionDeleteInput,
+  DTOForgeSectionMoveInput,
+  DTOForgeSectionUpdateInput,
+} from "./project-section";
+
+export const DTOForgeProjectActionFeatureCreate = z.object({
+  type: z.literal("FeatureCreate"),
+  input: DTOForgeProjectFeatureCreateInput,
+});
+
+export const DTOForgeProjectActionFeatureUpdate = z.object({
+  type: z.literal("FeatureUpdate"),
+  input: DTOForgeProjectFeatureUpdateInput,
+});
+
+export const DTOForgeProjectActionFeatureMove = z.object({
+  type: z.literal("FeatureMove"),
+  input: DTOForgeProjectFeatureMoveInput,
+});
+
+export const DTOForgeProjectActionFeatureDelete = z.object({
+  type: z.literal("FeatureDelete"),
+  input: DTOForgeProjectFeatureDeleteInput,
+});
+
+export const DTOForgeProjectActionArtifactCreate = z.object({
+  type: z.literal("ArtifactCreate"),
+  input: DTOForgeProjectArtifactCreateInput,
+});
+
+export const DTOForgeProjectActionArtifactUpdate = z.object({
+  type: z.literal("ArtifactUpdate"),
+  input: DTOForgeProjectArtifactUpdateInput,
+});
+
+export const DTOForgeProjectActionArtifactDelete = z.object({
+  type: z.literal("ArtifactDelete"),
+  input: DTOForgeProjectArtifactDeleteInput,
+});
+
+export const DTOForgeProjectActionArtifactMove = z.object({
+  type: z.literal("ArtifactMove"),
+  input: DTOForgeProjectArtifactMoveInput,
+});
+
+export const DTOForgeProjectActionSectionCreate = z.object({
+  type: z.literal("SectionCreate"),
+  input: DTOForgeSectionCreateInput,
+});
+
+export const DTOForgeProjectActionSectionUpdate = z.object({
+  type: z.literal("SectionUpdate"),
+  input: DTOForgeSectionUpdateInput,
+});
+
+export const DTOForgeProjectActionSectionDelete = z.object({
+  type: z.literal("SectionDelete"),
+  input: DTOForgeSectionDeleteInput,
+});
+
+export const DTOForgeProjectActionSectionMove = z.object({
+  type: z.literal("SectionMove"),
+  input: DTOForgeSectionMoveInput,
+});
+
+export const DTOForgeProjectAction = z
+  .discriminatedUnion("type", [
+    //features
+    DTOForgeProjectActionFeatureCreate,
+    DTOForgeProjectActionFeatureUpdate,
+    DTOForgeProjectActionFeatureDelete,
+    DTOForgeProjectActionFeatureMove,
+    //artifacts
+    DTOForgeProjectActionArtifactCreate,
+    DTOForgeProjectActionArtifactUpdate,
+    DTOForgeProjectActionArtifactDelete,
+    DTOForgeProjectActionArtifactMove,
+    //section
+    DTOForgeProjectActionSectionCreate,
+    DTOForgeProjectActionSectionUpdate,
+    DTOForgeProjectActionSectionDelete,
+    DTOForgeProjectActionSectionMove,
+  ])
+  .and(
+    z.object({
+      tId: z.string().optional(),
+    })
+  );
+
+export type DTOForgeProjectActionFeatureCreate = z.infer<typeof DTOForgeProjectActionFeatureCreate>;
+export type DTOForgeProjectActionFeatureUpdate = z.infer<typeof DTOForgeProjectActionFeatureUpdate>;
+export type DTOForgeProjectActionFeatureDelete = z.infer<typeof DTOForgeProjectActionFeatureDelete>;
+export type DTOForgeProjectActionFeatureMove = z.infer<typeof DTOForgeProjectActionFeatureMove>;
+export type DTOForgeProjectActionArtifactCreate = z.infer<typeof DTOForgeProjectActionArtifactCreate>;
+export type DTOForgeProjectActionArtifactUpdate = z.infer<typeof DTOForgeProjectActionArtifactUpdate>;
+export type DTOForgeProjectActionArtifactDelete = z.infer<typeof DTOForgeProjectActionArtifactDelete>;
+export type DTOForgeProjectActionArtifactMove = z.infer<typeof DTOForgeProjectActionArtifactMove>;
+export type DTOForgeProjectActionSectionCreate = z.infer<typeof DTOForgeProjectActionSectionCreate>;
+export type DTOForgeProjectActionSectionUpdate = z.infer<typeof DTOForgeProjectActionSectionUpdate>;
+export type DTOForgeProjectActionSectionDelete = z.infer<typeof DTOForgeProjectActionSectionDelete>;
+export type DTOForgeProjectActionSectionMove = z.infer<typeof DTOForgeProjectActionSectionMove>;
+
+export type DTOForgeProjectAction = z.infer<typeof DTOForgeProjectAction>;
+export type DTOForgeProjectActionType = DTOForgeProjectAction["type"];
+export type DTOForgeProjectActionOfType<T extends DTOForgeProjectActionType> = Extract<
+  DTOForgeProjectAction,
+  { type: T }
+>;

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

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

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

@@ -0,0 +1,85 @@
+import { ForgeProjectArtifact, ForgeProjectArtifactContentData, Id } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOThreadMessageCreateInput } from "../threads";
+import { DTOForgeSectionItemMoveInput } from "./project-section";
+
+const omitProps = {
+  projectId: true,
+  createdByUserId: true,
+  createdAt: true,
+  updatedAt: true,
+  sortOrder: true,
+} as const;
+
+export const DTOForgeProjectArtifact = ForgeProjectArtifact;
+export const DTOForgeProjectArtifactUpdateInput = z.object({
+  id: z.string(),
+  title: z.string().optional(),
+  isArchived: z.boolean().optional(),
+});
+
+export const DTOForgeProjectArtifactCreateInput = z.object({
+  id: z.string(),
+  title: z.string(),
+  sectionId: z.string().optional(),
+  afterArtifactId: z.string().optional().nullable(),
+  initialMessage: DTOThreadMessageCreateInput.optional(),
+});
+
+export const DTOForgeProjectArtifactDeleteInput = z.object({
+  id: Id,
+});
+
+export const DTOForgeProjectArtifactMoveInput = DTOForgeSectionItemMoveInput;
+
+export const DTOForgeDocumentGetByIdParam = z.object({
+  id: Id,
+});
+
+export const DTOForgeProjectArtifactGetResponse = z.object({
+  artifact: DTOForgeProjectArtifact,
+});
+
+export const DTOForgeDocumentGetResponse = z.object({
+  document: DTOForgeProjectArtifact,
+});
+
+export const DTOForgeProjectArtifactCreateResponse = z.object({
+  artifact: DTOForgeProjectArtifact,
+});
+
+export const DTOForgeProjectArtifactUpdateResponse = z.object({
+  artifact: DTOForgeProjectArtifact,
+});
+
+export const DTOForgeProjectArtifactDeleteResponse = z.object({
+  ok: z.literal(true),
+});
+
+export const DTOForgeProjectArtifactMoveResponse = z.object({
+  artifact: DTOForgeProjectArtifact,
+});
+
+export const DTOForgeProjectArtifactsListResponse = z.object({
+  artifacts: z.array(DTOForgeProjectArtifact),
+});
+
+export const DTOForgeProjectArtifactContentResponse = z.object({
+  artifactId: z.string(),
+  content: ForgeProjectArtifactContentData,
+});
+
+export type DTOForgeProjectArtifact = z.infer<typeof DTOForgeProjectArtifact>;
+export type DTOForgeProjectArtifactUpdateInput = z.infer<typeof DTOForgeProjectArtifactUpdateInput>;
+export type DTOForgeProjectArtifactCreateInput = z.infer<typeof DTOForgeProjectArtifactCreateInput>;
+export type DTOForgeProjectArtifactDeleteInput = z.infer<typeof DTOForgeProjectArtifactDeleteInput>;
+export type DTOForgeProjectArtifactMoveInput = z.infer<typeof DTOForgeProjectArtifactMoveInput>;
+export type DTOForgeDocumentGetByIdParam = z.infer<typeof DTOForgeDocumentGetByIdParam>;
+export type DTOForgeProjectArtifactGetResponse = z.infer<typeof DTOForgeProjectArtifactGetResponse>;
+export type DTOForgeProjectArtifactCreateResponse = z.infer<typeof DTOForgeProjectArtifactCreateResponse>;
+export type DTOForgeProjectArtifactUpdateResponse = z.infer<typeof DTOForgeProjectArtifactUpdateResponse>;
+export type DTOForgeProjectArtifactDeleteResponse = z.infer<typeof DTOForgeProjectArtifactDeleteResponse>;
+export type DTOForgeProjectArtifactMoveResponse = z.infer<typeof DTOForgeProjectArtifactMoveResponse>;
+export type DTOForgeProjectArtifactsListResponse = z.infer<typeof DTOForgeProjectArtifactsListResponse>;
+export type DTOForgeProjectArtifactContentResponse = z.infer<typeof DTOForgeProjectArtifactContentResponse>;
+export type DTOForgeDocumentGetResponse = z.infer<typeof DTOForgeDocumentGetResponse>;