@supernova-studio/client 1.17.1 → 1.17.3

package/dist/index.mjs

@@ -187,9 +187,9 @@ import { z as z175 } from "zod";
 import { z as z177 } from "zod";
 import { z as z178 } from "zod";
 import { z as z179 } from "zod";
+import { z as z181 } from "zod";
 import { z as z180 } from "zod";
 import { z as z182 } from "zod";
-import { z as z181 } from "zod";
 import { z as z183 } from "zod";
 import { z as z185 } from "zod";
 import { z as z186 } from "zod";
@@ -5143,22 +5143,14 @@ var ForgeMeta = z173.object({
   name: z173.string(),
   description: z173.string().optional()
 });
-var ForgeProjectTag = z174.array(z174.string()).default([]);
-var ForgeProjectAccessMode = z174.enum(["InviteOnly", "Open"]);
-var ForgeProject = z174.object({
-  createdAt: z174.coerce.date(),
-  createdByUserId: z174.string().optional(),
-  fpContextId: z174.string(),
+var ForgeProjectArtifactContentData = DocumentationPageContentData;
+var ForgeProjectArtifactContent = z174.object({
   id: z174.string(),
-  instruction: z174.string().nullable(),
-  meta: ForgeMeta,
-  name: z174.string(),
-  tags: ForgeProjectTag,
-  updatedAt: z174.coerce.date().optional(),
-  workspaceId: z174.string(),
-  accessMode: ForgeProjectAccessMode,
-  isArchived: z174.boolean().optional(),
-  emoji: z174.string().optional()
+  artifactId: z174.string(),
+  projectId: z174.string(),
+  createdAt: z174.coerce.date(),
+  updatedAt: z174.coerce.date(),
+  data: ForgeProjectArtifactContentData
 });
 var ForgeProjectSectionChildType = z175.enum(["Artifact", "Feature"]);
 var SortOrder = z175.number().int().min(0);
@@ -5183,95 +5175,105 @@ var ForgeProjectArtifact = z176.object({
   createdByUserId: z176.string(),
   sectionId: Id.optional()
 });
-var ForgeProjectArtifactContentData = DocumentationPageContentData;
-var ForgeProjectArtifactContent = z177.object({
-  id: z177.string(),
-  artifactId: z177.string(),
-  projectId: z177.string(),
-  createdAt: z177.coerce.date(),
-  updatedAt: z177.coerce.date(),
-  data: ForgeProjectArtifactContentData
-});
-var ForgeProjectContextDependency = z178.object({
-  packageName: z178.string(),
-  type: z178.literal("npm"),
-  version: z178.string().default("latest")
+var ForgeProjectContextDependency = z177.object({
+  packageName: z177.string(),
+  type: z177.literal("npm"),
+  version: z177.string().default("latest")
 });
-var ForgeProjectContextTailwindConfig = z178.object({
-  content: z178.string(),
-  version: z178.string()
+var ForgeProjectContextTailwindConfig = z177.object({
+  content: z177.string(),
+  version: z177.string()
 });
-var ForgeProjectContext = z178.object({
-  createdAt: z178.coerce.date(),
-  definition: z178.string(),
-  dependencies: z178.array(ForgeProjectContextDependency),
-  designSystemId: z178.string(),
-  id: z178.string(),
+var ForgeProjectContext = z177.object({
+  createdAt: z177.coerce.date(),
+  definition: z177.string(),
+  dependencies: z177.array(ForgeProjectContextDependency),
+  designSystemId: z177.string(),
+  id: z177.string(),
   meta: ForgeMeta,
-  name: z178.string(),
+  name: z177.string(),
   npmProxySettings: NpmRegistryConfig,
-  platform: z178.enum(["React", "Vue", "Angular"]),
-  styling: z178.enum(["CSS", "Tailwind"]),
+  platform: z177.enum(["React", "Vue", "Angular"]),
+  styling: z177.enum(["CSS", "Tailwind"]),
   tailwindConfig: ForgeProjectContextTailwindConfig.optional(),
-  updatedAt: z178.coerce.date(),
-  workspaceId: z178.string()
+  updatedAt: z177.coerce.date(),
+  workspaceId: z177.string()
 });
-var ProjectFeature = z179.object({
-  createdAt: z179.coerce.date(),
-  createdByUserId: z179.string(),
-  description: z179.string(),
+var ProjectFeatureStatus = z178.enum(["Draft", "ReadyForDevelopment"]);
+var ProjectFeature = z178.object({
+  createdAt: z178.coerce.date(),
+  createdByUserId: z178.string(),
+  description: z178.string(),
   id: Id,
-  isArchived: z179.boolean().optional(),
-  name: z179.string(),
-  projectId: z179.string(),
+  isArchived: z178.boolean().optional(),
+  name: z178.string(),
+  projectId: z178.string(),
   sectionId: Id.optional(),
   sortOrder: SortOrder.default(0),
-  updatedAt: z179.coerce.date().optional()
+  status: ProjectFeatureStatus.default("Draft"),
+  updatedAt: z178.coerce.date().optional()
 });
-var ForgeProjectFigmaNode = z180.object({
-  id: z180.string().uuid(),
-  projectId: z180.string(),
-  sceneNodeId: z180.string(),
+var ForgeProjectFigmaNode = z179.object({
+  id: z179.string().uuid(),
+  projectId: z179.string(),
+  sceneNodeId: z179.string(),
   format: FigmaNodeRenderFormat,
-  scale: z180.number().optional(),
+  scale: z179.number().optional(),
   renderState: FigmaNodeRenderState,
   renderedImage: FigmaNodeRenderedImage.optional(),
   renderError: FigmaNodeRenderError.optional()
 });
-var ForgeProjectFigmaNodeRenderInput = z180.object({
-  url: z180.string(),
+var ForgeProjectFigmaNodeRenderInput = z179.object({
+  url: z179.string(),
   format: FigmaNodeRenderFormat,
-  scale: z180.number()
+  scale: z179.number()
 });
-var ForgeProjectRole = z181.enum(["Viewer", "Editor", "Admin"]);
-var ForgeProjectMembership = z181.object({
-  userId: z181.string(),
-  forgeProjectId: z181.string(),
-  workspaceMembershipId: z181.string(),
+var ForgeProjectRole = z180.enum(["Viewer", "Editor", "Admin"]);
+var ForgeProjectMembership = z180.object({
+  userId: z180.string(),
+  forgeProjectId: z180.string(),
+  workspaceMembershipId: z180.string(),
   workspaceRole: WorkspaceRoleSchema,
   role: ForgeProjectRole
 });
-var ForgeProjectInvitation = z182.object({
-  email: z182.string().email(),
-  forgeProjectId: z182.string(),
-  workspaceInvitationId: z182.string(),
+var ForgeProjectInvitation = z181.object({
+  email: z181.string().email(),
+  forgeProjectId: z181.string(),
+  workspaceInvitationId: z181.string(),
   role: ForgeProjectRole,
+  createdAt: z181.coerce.date(),
+  updatedAt: z181.coerce.date(),
+  createdById: z181.string()
+});
+var ForgeProjectIterationMergeMeta = z182.object({ mergeByUserId: z182.string(), mergeAt: z182.date() });
+var ForgeProjectIteration = z182.object({
+  branchId: z182.string().optional(),
+  buildArtifactId: z182.string(),
   createdAt: z182.coerce.date(),
-  updatedAt: z182.coerce.date(),
-  createdById: z182.string()
+  forgeProjectId: z182.string(),
+  id: z182.string(),
+  locked: z182.boolean(),
+  messages: z182.array(ForgeIterationMessage),
+  artifacts: z182.array(ForgeArtifact),
+  previousIterationId: z182.string().optional(),
+  mergeMeta: ForgeProjectIterationMergeMeta.optional()
 });
-var ForgeProjectIterationMergeMeta = z183.object({ mergeByUserId: z183.string(), mergeAt: z183.date() });
-var ForgeProjectIteration = z183.object({
-  branchId: z183.string().optional(),
-  buildArtifactId: z183.string(),
+var ForgeProjectTag = z183.array(z183.string()).default([]);
+var ForgeProjectAccessMode = z183.enum(["InviteOnly", "Open"]);
+var ForgeProject = z183.object({
   createdAt: z183.coerce.date(),
-  forgeProjectId: z183.string(),
+  createdByUserId: z183.string().optional(),
+  fpContextId: z183.string(),
   id: z183.string(),
-  locked: z183.boolean(),
-  messages: z183.array(ForgeIterationMessage),
-  artifacts: z183.array(ForgeArtifact),
-  previousIterationId: z183.string().optional(),
-  mergeMeta: ForgeProjectIterationMergeMeta.optional()
+  instruction: z183.string().nullable(),
+  meta: ForgeMeta,
+  name: z183.string(),
+  tags: ForgeProjectTag,
+  updatedAt: z183.coerce.date().optional(),
+  workspaceId: z183.string(),
+  accessMode: ForgeProjectAccessMode,
+  isArchived: z183.boolean().optional(),
+  emoji: z183.string().optional()
 });
 var ForgeProjectRoom = Entity.extend({
   projectId: z184.string(),
@@ -7218,6 +7220,33 @@ var DTOWorkspaceMembersListResponse = z245.object({
 
 // src/api/dto/workspaces/subscription.ts
 import z246 from "zod";
+var DTOCreditBalance = z246.object({
+  paidTopUp: z246.object({
+    total: z246.number(),
+    used: z246.number(),
+    balance: z246.number()
+  }).optional(),
+  paidRecurring: z246.object({
+    total: z246.number(),
+    used: z246.number(),
+    balance: z246.number(),
+    resetAt: z246.string().optional()
+  }).optional(),
+  free: z246.object({
+    credits: z246.object({
+      total: z246.number(),
+      used: z246.number(),
+      balance: z246.number(),
+      resetAt: z246.string().optional()
+    }),
+    spendingLimit: z246.object({
+      total: z246.number(),
+      used: z246.number(),
+      balance: z246.number(),
+      resetAt: z246.string().optional()
+    })
+  }).optional()
+}).optional();
 var DTOSubscription = z246.object({
   stripeSubscriptionId: z246.string().optional(),
   stripeCustomerId: z246.string().optional(),
@@ -7245,23 +7274,11 @@ var DTOSubscription = z246.object({
   amount: z246.number(),
   isTrial: z246.boolean(),
   billingType: BillingTypeSchema.optional(),
-  daysUntilDue: z246.number().optional(),
-  creditBalance: z246.object({
-    oneTime: z246.object({
-      total: z246.number(),
-      used: z246.number(),
-      balance: z246.number()
-    }),
-    recurring: z246.object({
-      total: z246.number(),
-      used: z246.number(),
-      balance: z246.number(),
-      resetAt: z246.string().optional()
-    })
-  }).optional()
+  daysUntilDue: z246.number().optional()
 });
 var DTOSubscriptionResponse = z246.object({
-  subscription: DTOSubscription
+  subscription: DTOSubscription,
+  creditBalance: DTOCreditBalance
 });
 
 // src/api/dto/workspaces/transfer-ownership.ts
@@ -9091,120 +9108,15 @@ var DTODeleteForgeIterationMessageResponse = z311.object({
   ok: z311.literal(true)
 });
 
-// src/api/dto/forge/project.ts
-import { z as z314 } from "zod";
-
-// src/api/dto/forge/project-member.ts
-import { z as z313 } from "zod";
-
-// src/api/dto/forge/project-invitation.ts
-import { z as z312 } from "zod";
-var DTOForgeProjectInvitation = ForgeProjectInvitation;
-var DTOCreateForgeProjectInvitation = DTOForgeProjectInvitation.pick({
-  email: true,
-  role: true
-}).extend({
-  workspaceRole: WorkspaceRoleSchema
-});
-var DTOUpdateForgeProjectInvitation = DTOCreateForgeProjectInvitation.omit({
-  email: true,
-  workspaceRole: true
-});
-var DTORemoveForgeProjectInvitation = DTOCreateForgeProjectInvitation.pick({
-  email: true
-});
-var DTOForgeProjectInvitationsListResponse = z312.object({
-  invitations: z312.array(DTOForgeProjectInvitation)
-});
-var DTOForgeProjectInvitationGetResponse = z312.object({
-  invitation: DTOForgeProjectInvitation
-});
-var DTOForgeProjectInvitationCreateResponse = z312.object({
-  invitation: DTOForgeProjectInvitation
-});
-var DTOForgeProjectInvitationUpdateResponse = z312.object({
-  invitation: DTOForgeProjectInvitation.nullable()
-});
-var DTOForgeProjectInvitationRemoveResponse = z312.object({
-  ok: z312.literal(true)
-});
-
-// src/api/dto/forge/project-member.ts
-var DTOForgeProjectMemberRole = ForgeProjectRole;
-var DTOForgeProjectMember = ForgeProjectMembership.extend({
-  user: DTOUser,
-  effectiveRole: DTOForgeProjectMemberRole
-});
-var DTOCreateForgeProjectMember = DTOForgeProjectMember.pick({
-  userId: true,
-  role: true
-});
-var DTOUpdateForgeProjectMember = DTOCreateForgeProjectMember.omit({ userId: true });
-var DTORemoveForgeProjectMember = DTOForgeProjectMember.pick({
-  userId: true
-});
-var DTOForgeProjectMembersListResponse = z313.object({
-  members: z313.array(DTOForgeProjectMember),
-  invitations: z313.array(DTOForgeProjectInvitation)
-});
-var DTOForgeProjectMemberGetResponse = z313.object({
-  member: DTOForgeProjectMember
-});
-var DTOForgeProjectMemberCreateResponse = z313.object({
-  member: DTOForgeProjectMember
-});
-var DTOForgeProjectMemberUpdateResponse = z313.object({
-  member: DTOForgeProjectMember.nullable()
-});
-var DTOForgeProjectMemberRemoveResponse = z313.object({
-  ok: z313.literal(true)
-});
-var DTOAddMembersToForgeProject = z313.object({
-  membersToInvite: DTOCreateForgeProjectInvitation.array().min(1)
-});
-
-// src/api/dto/forge/project.ts
-var DTOForgeProject = ForgeProject.omit({ fpContextId: true }).extend({
-  context: ForgeProjectContext,
-  members: z314.array(DTOForgeProjectMember),
-  invitations: z314.array(DTOForgeProjectInvitation)
-});
-var DTOCreateForgeProject = ForgeProject.pick({
-  instruction: true,
-  name: true,
-  meta: true,
-  tags: true,
-  accessMode: true,
-  fpContextId: true,
-  isArchived: true,
-  emoji: true
-}).extend({ membersToInvite: DTOCreateForgeProjectInvitation.array().min(1).optional() });
-var DTOUpdateForgeProject = DTOCreateForgeProject.omit({ membersToInvite: true }).partial().extend({
-  id: z314.string(),
-  membersToRetain: z314.string().array().min(1).optional()
-});
-var DTOForgeProjectGetResponse = z314.object({ project: DTOForgeProject.nullable() });
-var DTOForgeProjectsListResponse = z314.object({ projects: z314.array(DTOForgeProject) });
-var DTOCreateForgeProjectResponse = z314.object({
-  project: DTOForgeProject
-});
-var DTOUpdateForgeProjectResponse = z314.object({
-  project: DTOForgeProject
-});
-var DTOUGetForgeProjectResponse = z314.object({
-  project: DTOForgeProject
-});
-var DTORemoveForgeProjectResponse = z314.object({ ok: z314.literal(true) });
-
 // src/api/dto/forge/project-action.ts
-import z318 from "zod";
+import z315 from "zod";
 
 // src/api/dto/forge/project-artifact.ts
-import { z as z316 } from "zod";
+import { z as z313 } from "zod";
 
 // src/api/dto/forge/project-section.ts
-import z315 from "zod";
-var AfterSectionId = z315.string().uuid().nullish().optional();
+import z312 from "zod";
+var AfterSectionId = z312.string().uuid().nullish().optional();
 var DTOForgeSection = ForgeSection;
 var DTOForgeSectionCreateInput = DTOForgeSection.pick({
   id: true,
@@ -9215,12 +9127,12 @@ var DTOForgeSectionCreateInput = DTOForgeSection.pick({
 });
 var DTOForgeSectionUpdateInput = DTOForgeSection.pick({ id: true, name: true });
 var DTOForgeSectionDeleteInput = DTOForgeSection.pick({ id: true }).extend({
-  deleteChildren: z315.boolean().default(false)
+  deleteChildren: z312.boolean().default(false)
 });
 var DTOForgeSectionMoveInput = DTOForgeSection.pick({ id: true }).extend({
   afterSectionId: AfterSectionId
 });
-var DTOForgeSectionItemMoveInput = z315.object({
+var DTOForgeSectionItemMoveInput = z312.object({
   id: Id,
   sectionId: Id.nullish().optional(),
   // undefined=stay, null=no section, string=move to section
@@ -9230,116 +9142,117 @@ var DTOForgeSectionItemMoveInput = z315.object({
 
 // src/api/dto/forge/project-artifact.ts
 var DTOForgeProjectArtifact = ForgeProjectArtifact;
-var DTOForgeProjectArtifactUpdateInput = z316.object({
-  id: z316.string(),
-  title: z316.string().optional()
+var DTOForgeProjectArtifactUpdateInput = z313.object({
+  id: z313.string(),
+  title: z313.string().optional()
 });
-var DTOForgeProjectArtifactCreateInput = z316.object({
-  id: z316.string(),
-  title: z316.string(),
-  sectionId: z316.string().optional(),
-  afterArtifactId: z316.string().optional().nullable()
+var DTOForgeProjectArtifactCreateInput = z313.object({
+  id: z313.string(),
+  title: z313.string(),
+  sectionId: z313.string().optional(),
+  afterArtifactId: z313.string().optional().nullable()
 });
-var DTOForgeProjectArtifactDeleteInput = z316.object({
+var DTOForgeProjectArtifactDeleteInput = z313.object({
   id: Id
 });
 var DTOForgeProjectArtifactMoveInput = DTOForgeSectionItemMoveInput;
-var DTOForgeProjectArtifactGetResponse = z316.object({
+var DTOForgeProjectArtifactGetResponse = z313.object({
   artifact: DTOForgeProjectArtifact
 });
-var DTOForgeProjectArtifactCreateResponse = z316.object({
+var DTOForgeProjectArtifactCreateResponse = z313.object({
   artifact: DTOForgeProjectArtifact
 });
-var DTOForgeProjectArtifactUpdateResponse = z316.object({
+var DTOForgeProjectArtifactUpdateResponse = z313.object({
   artifact: DTOForgeProjectArtifact
 });
-var DTOForgeProjectArtifactDeleteResponse = z316.object({
-  ok: z316.literal(true)
+var DTOForgeProjectArtifactDeleteResponse = z313.object({
+  ok: z313.literal(true)
 });
-var DTOForgeProjectArtifactMoveResponse = z316.object({
+var DTOForgeProjectArtifactMoveResponse = z313.object({
   artifact: DTOForgeProjectArtifact
 });
-var DTOForgeProjectArtifactsListResponse = z316.object({
-  artifacts: z316.array(DTOForgeProjectArtifact)
+var DTOForgeProjectArtifactsListResponse = z313.object({
+  artifacts: z313.array(DTOForgeProjectArtifact)
 });
 
 // src/api/dto/forge/project-feature.ts
-import z317 from "zod";
+import z314 from "zod";
 var DTOForgeProjectFeature = ProjectFeature;
-var DTOForgeProjectFeatureListResponse = z317.object({
+var DTOForgeProjectFeatureListResponse = z314.object({
   features: DTOForgeProjectFeature.array()
 });
-var DTOForgeProjectFeatureGetResponse = z317.object({
+var DTOForgeProjectFeatureGetResponse = z314.object({
   feature: DTOForgeProjectFeature
 });
-var DTOForgeProjectFeatureCreateInput = z317.object({
+var DTOForgeProjectFeatureCreateInput = z314.object({
   id: Id,
-  name: z317.string(),
-  description: z317.string(),
+  name: z314.string(),
+  description: z314.string(),
   sectionId: Id.optional(),
   afterFeatureId: Id.nullable().optional()
 });
-var DTOForgeProjectFeatureUpdateInput = z317.object({
+var DTOForgeProjectFeatureUpdateInput = z314.object({
   id: Id,
-  name: z317.string().optional(),
-  description: z317.string().optional(),
-  isArchived: z317.boolean().optional()
+  name: z314.string().optional(),
+  description: z314.string().optional(),
+  isArchived: z314.boolean().optional(),
+  status: ProjectFeatureStatus.optional()
 });
-var DTOForgeProjectFeatureDeleteInput = z317.object({
+var DTOForgeProjectFeatureDeleteInput = z314.object({
   id: Id
 });
 var DTOForgeProjectFeatureMoveInput = DTOForgeSectionItemMoveInput;
 
 // src/api/dto/forge/project-action.ts
-var DTOForgeProjectActionFeatureCreate = z318.object({
-  type: z318.literal("FeatureCreate"),
+var DTOForgeProjectActionFeatureCreate = z315.object({
+  type: z315.literal("FeatureCreate"),
   input: DTOForgeProjectFeatureCreateInput
 });
-var DTOForgeProjectActionFeatureUpdate = z318.object({
-  type: z318.literal("FeatureUpdate"),
+var DTOForgeProjectActionFeatureUpdate = z315.object({
+  type: z315.literal("FeatureUpdate"),
   input: DTOForgeProjectFeatureUpdateInput
 });
-var DTOForgeProjectActionFeatureMove = z318.object({
-  type: z318.literal("FeatureMove"),
+var DTOForgeProjectActionFeatureMove = z315.object({
+  type: z315.literal("FeatureMove"),
   input: DTOForgeProjectFeatureMoveInput
 });
-var DTOForgeProjectActionFeatureDelete = z318.object({
-  type: z318.literal("FeatureDelete"),
+var DTOForgeProjectActionFeatureDelete = z315.object({
+  type: z315.literal("FeatureDelete"),
   input: DTOForgeProjectFeatureDeleteInput
 });
-var DTOForgeProjectActionArtifactCreate = z318.object({
-  type: z318.literal("ArtifactCreate"),
+var DTOForgeProjectActionArtifactCreate = z315.object({
+  type: z315.literal("ArtifactCreate"),
   input: DTOForgeProjectArtifactCreateInput
 });
-var DTOForgeProjectActionArtifactUpdate = z318.object({
-  type: z318.literal("ArtifactUpdate"),
+var DTOForgeProjectActionArtifactUpdate = z315.object({
+  type: z315.literal("ArtifactUpdate"),
   input: DTOForgeProjectArtifactUpdateInput
 });
-var DTOForgeProjectActionArtifactDelete = z318.object({
-  type: z318.literal("ArtifactDelete"),
+var DTOForgeProjectActionArtifactDelete = z315.object({
+  type: z315.literal("ArtifactDelete"),
   input: DTOForgeProjectArtifactDeleteInput
 });
-var DTOForgeProjectActionArtifactMove = z318.object({
-  type: z318.literal("ArtifactMove"),
+var DTOForgeProjectActionArtifactMove = z315.object({
+  type: z315.literal("ArtifactMove"),
   input: DTOForgeProjectArtifactMoveInput
 });
-var DTOForgeProjectActionSectionCreate = z318.object({
-  type: z318.literal("SectionCreate"),
+var DTOForgeProjectActionSectionCreate = z315.object({
+  type: z315.literal("SectionCreate"),
   input: DTOForgeSectionCreateInput
 });
-var DTOForgeProjectActionSectionUpdate = z318.object({
-  type: z318.literal("SectionUpdate"),
+var DTOForgeProjectActionSectionUpdate = z315.object({
+  type: z315.literal("SectionUpdate"),
   input: DTOForgeSectionUpdateInput
 });
-var DTOForgeProjectActionSectionDelete = z318.object({
-  type: z318.literal("SectionDelete"),
+var DTOForgeProjectActionSectionDelete = z315.object({
+  type: z315.literal("SectionDelete"),
   input: DTOForgeSectionDeleteInput
 });
-var DTOForgeProjectActionSectionMove = z318.object({
-  type: z318.literal("SectionMove"),
+var DTOForgeProjectActionSectionMove = z315.object({
+  type: z315.literal("SectionMove"),
   input: DTOForgeSectionMoveInput
 });
-var DTOForgeProjectAction = z318.discriminatedUnion("type", [
+var DTOForgeProjectAction = z315.discriminatedUnion("type", [
   //features
   DTOForgeProjectActionFeatureCreate,
   DTOForgeProjectActionFeatureUpdate,
@@ -9356,22 +9269,22 @@ var DTOForgeProjectAction = z318.discriminatedUnion("type", [
   DTOForgeProjectActionSectionDelete,
   DTOForgeProjectActionSectionMove
 ]).and(
-  z318.object({
-    tId: z318.string().optional()
+  z315.object({
+    tId: z315.string().optional()
   })
 );
 
 // src/api/dto/forge/project-artifact-room.ts
-import { z as z319 } from "zod";
-var DTOForgeProjectArtifactRoom = z319.object({
-  id: z319.string()
+import { z as z316 } from "zod";
+var DTOForgeProjectArtifactRoom = z316.object({
+  id: z316.string()
 });
-var DTOForgeProjectArtifactRoomResponse = z319.object({
+var DTOForgeProjectArtifactRoomResponse = z316.object({
   room: DTOForgeProjectArtifactRoom
 });
 
 // src/api/dto/forge/project-context.ts
-import { z as z320 } from "zod";
+import { z as z317 } from "zod";
 var DTOForgeProjectContext = ForgeProjectContext;
 var DTOCreateForgeProjectContext = DTOForgeProjectContext.pick({
   definition: true,
@@ -9383,21 +9296,53 @@ var DTOCreateForgeProjectContext = DTOForgeProjectContext.pick({
   tailwindConfig: true,
   styling: true
 }).extend({ npmProxySettings: DTONpmRegistryConfig });
-var DTOUpdateForgeProjectContext = DTOCreateForgeProjectContext.partial().extend({ id: z320.string() });
-var DTOForgeProjectContextGetResponse = z320.object({ context: DTOForgeProjectContext });
-var DTOForgeProjectContextListResponse = z320.object({ contexts: z320.array(DTOForgeProjectContext) });
-var DTOForgeProjectContextCreateResponse = z320.object({ context: DTOForgeProjectContext });
-var DTOForgeProjectContextUpdateResponse = z320.object({ context: DTOForgeProjectContext });
-var DTOForgeProjectContextRemoveResponse = z320.object({
-  ok: z320.literal(true)
+var DTOUpdateForgeProjectContext = DTOCreateForgeProjectContext.partial().extend({ id: z317.string() });
+var DTOForgeProjectContextGetResponse = z317.object({ context: DTOForgeProjectContext });
+var DTOForgeProjectContextListResponse = z317.object({ contexts: z317.array(DTOForgeProjectContext) });
+var DTOForgeProjectContextCreateResponse = z317.object({ context: DTOForgeProjectContext });
+var DTOForgeProjectContextUpdateResponse = z317.object({ context: DTOForgeProjectContext });
+var DTOForgeProjectContextRemoveResponse = z317.object({
+  ok: z317.literal(true)
 });
 
 // src/api/dto/forge/project-figma-node.ts
 var DTOForgeProjectFigmaNode = ForgeProjectFigmaNode;
 var DTOForgeProjectFigmaNodeRenderInput = ForgeProjectFigmaNodeRenderInput;
 
+// src/api/dto/forge/project-invitation.ts
+import { z as z318 } from "zod";
+var DTOForgeProjectInvitation = ForgeProjectInvitation;
+var DTOCreateForgeProjectInvitation = DTOForgeProjectInvitation.pick({
+  email: true,
+  role: true
+}).extend({
+  workspaceRole: WorkspaceRoleSchema
+});
+var DTOUpdateForgeProjectInvitation = DTOCreateForgeProjectInvitation.omit({
+  email: true,
+  workspaceRole: true
+});
+var DTORemoveForgeProjectInvitation = DTOCreateForgeProjectInvitation.pick({
+  email: true
+});
+var DTOForgeProjectInvitationsListResponse = z318.object({
+  invitations: z318.array(DTOForgeProjectInvitation)
+});
+var DTOForgeProjectInvitationGetResponse = z318.object({
+  invitation: DTOForgeProjectInvitation
+});
+var DTOForgeProjectInvitationCreateResponse = z318.object({
+  invitation: DTOForgeProjectInvitation
+});
+var DTOForgeProjectInvitationUpdateResponse = z318.object({
+  invitation: DTOForgeProjectInvitation.nullable()
+});
+var DTOForgeProjectInvitationRemoveResponse = z318.object({
+  ok: z318.literal(true)
+});
+
 // src/api/dto/forge/project-iteration.ts
-import { z as z321 } from "zod";
+import { z as z319 } from "zod";
 var DTOForgeProjectIterationMergeMeta = ForgeProjectIterationMergeMeta;
 var DTOForgeProjectIteration = ForgeProjectIteration.omit({
   artifacts: true,
@@ -9408,7 +9353,7 @@ var DTOForgeProjectIteration = ForgeProjectIteration.omit({
   messages: DTOForgeIterationMessage.array(),
   mergeMeta: DTOForgeProjectIterationMergeMeta.optional()
 });
-var DTOGetForgeProjectIterationResponse = z321.object({
+var DTOGetForgeProjectIterationResponse = z319.object({
   iteration: DTOForgeProjectIteration.nullable()
 });
 var DTOCreateForgeProjectIteration = DTOForgeProjectIteration.omit({
@@ -9418,27 +9363,96 @@ var DTOCreateForgeProjectIteration = DTOForgeProjectIteration.omit({
   mergeMeta: true,
   createdAt: true
 });
-var DTOUpdateForgeProjectIteration = DTOCreateForgeProjectIteration.extend({ id: z321.string() });
-var DTOCreateForgeProjectIterationResponse = z321.object({
+var DTOUpdateForgeProjectIteration = DTOCreateForgeProjectIteration.extend({ id: z319.string() });
+var DTOCreateForgeProjectIterationResponse = z319.object({
   iteration: DTOForgeProjectIteration
 });
-var DTOUpdateForgeProjectIterationResponse = z321.object({
+var DTOUpdateForgeProjectIterationResponse = z319.object({
   iteration: DTOForgeProjectIteration.nullable()
 });
-var DTODeleteForgeProjectIterationResponse = z321.object({
-  ok: z321.literal(true)
+var DTODeleteForgeProjectIterationResponse = z319.object({
+  ok: z319.literal(true)
+});
+var DTOForgeProjectIterationListResponse = z319.object({ iterations: z319.array(DTOForgeProjectIteration) });
+
+// src/api/dto/forge/project-member.ts
+import { z as z320 } from "zod";
+var DTOForgeProjectMemberRole = ForgeProjectRole;
+var DTOForgeProjectMember = ForgeProjectMembership.extend({
+  user: DTOUser,
+  effectiveRole: DTOForgeProjectMemberRole
+});
+var DTOCreateForgeProjectMember = DTOForgeProjectMember.pick({
+  userId: true,
+  role: true
+});
+var DTOUpdateForgeProjectMember = DTOCreateForgeProjectMember.omit({ userId: true });
+var DTORemoveForgeProjectMember = DTOForgeProjectMember.pick({
+  userId: true
+});
+var DTOForgeProjectMembersListResponse = z320.object({
+  members: z320.array(DTOForgeProjectMember),
+  invitations: z320.array(DTOForgeProjectInvitation)
+});
+var DTOForgeProjectMemberGetResponse = z320.object({
+  member: DTOForgeProjectMember
+});
+var DTOForgeProjectMemberCreateResponse = z320.object({
+  member: DTOForgeProjectMember
+});
+var DTOForgeProjectMemberUpdateResponse = z320.object({
+  member: DTOForgeProjectMember.nullable()
+});
+var DTOForgeProjectMemberRemoveResponse = z320.object({
+  ok: z320.literal(true)
+});
+var DTOAddMembersToForgeProject = z320.object({
+  membersToInvite: DTOCreateForgeProjectInvitation.array().min(1)
 });
-var DTOForgeProjectIterationListResponse = z321.object({ iterations: z321.array(DTOForgeProjectIteration) });
 
 // src/api/dto/forge/project-room.ts
-import { z as z322 } from "zod";
-var DTOForgeProjectRoom = z322.object({
-  id: z322.string()
+import { z as z321 } from "zod";
+var DTOForgeProjectRoom = z321.object({
+  id: z321.string()
 });
-var DTOForgeProjectRoomResponse = z322.object({
+var DTOForgeProjectRoomResponse = z321.object({
   room: DTOForgeProjectRoom
 });
 
+// src/api/dto/forge/project.ts
+import { z as z322 } from "zod";
+var DTOForgeProject = ForgeProject.omit({ fpContextId: true }).extend({
+  context: ForgeProjectContext,
+  members: z322.array(DTOForgeProjectMember),
+  invitations: z322.array(DTOForgeProjectInvitation)
+});
+var DTOCreateForgeProject = ForgeProject.pick({
+  instruction: true,
+  name: true,
+  meta: true,
+  tags: true,
+  accessMode: true,
+  fpContextId: true,
+  isArchived: true,
+  emoji: true
+}).extend({ membersToInvite: DTOCreateForgeProjectInvitation.array().min(1).optional() });
+var DTOUpdateForgeProject = DTOCreateForgeProject.omit({ membersToInvite: true }).partial().extend({
+  id: z322.string(),
+  membersToRetain: z322.string().array().min(1).optional()
+});
+var DTOForgeProjectGetResponse = z322.object({ project: DTOForgeProject.nullable() });
+var DTOForgeProjectsListResponse = z322.object({ projects: z322.array(DTOForgeProject) });
+var DTOCreateForgeProjectResponse = z322.object({
+  project: DTOForgeProject
+});
+var DTOUpdateForgeProjectResponse = z322.object({
+  project: DTOForgeProject
+});
+var DTOUGetForgeProjectResponse = z322.object({
+  project: DTOForgeProject
+});
+var DTORemoveForgeProjectResponse = z322.object({ ok: z322.literal(true) });
+
 // src/api/dto/forge/threads.ts
 import { z as z323 } from "zod";
 var DTOForgeChatMessage = ForgeChatMessage;
@@ -17215,18 +17229,24 @@ var LocalProjectActionExecutor = class {
         return this.artifactUpdate(trx);
       case "ArtifactDelete":
         return this.artifactDelete(trx);
+      case "ArtifactMove":
+        return this.artifactMove(trx);
       case "FeatureCreate":
         return this.featureCreate(trx);
       case "FeatureDelete":
         return this.featureDelete(trx);
       case "FeatureUpdate":
         return this.featureUpdate(trx);
+      case "FeatureMove":
+        return this.featureMove(trx);
       case "SectionCreate":
         return this.sectionCreate(trx);
       case "SectionUpdate":
         return this.sectionUpdate(trx);
       case "SectionDelete":
         return this.sectionDelete(trx);
+      case "SectionMove":
+        return this.sectionMove(trx);
     }
   }
   //
@@ -17234,11 +17254,13 @@ var LocalProjectActionExecutor = class {
   //
   artifactCreate(trx) {
     const { input } = trx;
-    const { id } = input;
+    const { id, afterArtifactId, sectionId } = input;
+    const sortOrder = this.calculateItemSortOrder(this.artifacts, afterArtifactId, sectionId);
     this.artifacts.set(id, {
       id,
       projectId: this.projectId,
-      sortOrder: 0,
+      sectionId,
+      sortOrder,
       title: input.title,
       updatedAt: /* @__PURE__ */ new Date(),
       createdAt: /* @__PURE__ */ new Date(),
@@ -17259,6 +17281,21 @@ var LocalProjectActionExecutor = class {
     };
     this.artifacts.set(id, mergedArtifact);
   }
+  artifactMove(trx) {
+    const { input } = trx;
+    const { id, afterId, sectionId } = input;
+    const existingArtifact = this.artifacts.get(id);
+    if (!existingArtifact) {
+      throw new Error(`Cannot move artifact: artifact ${id} was not found in local storage`);
+    }
+    const sortOrder = this.calculateItemSortOrder(this.artifacts, afterId, sectionId);
+    const mergedArtifact = {
+      ...existingArtifact,
+      sortOrder,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.artifacts.set(id, mergedArtifact);
+  }
   artifactDelete(trx) {
     const { input } = trx;
     const { id } = input;
@@ -17271,15 +17308,17 @@ var LocalProjectActionExecutor = class {
   //
   featureCreate(trx) {
     const { input } = trx;
-    const { id } = input;
+    const { id, afterFeatureId, sectionId } = input;
+    const sortOrder = this.calculateItemSortOrder(this.features, afterFeatureId, sectionId);
     this.features.set(id, {
       id,
       projectId: this.projectId,
       description: input.description,
       isArchived: false,
       sectionId: input.sectionId,
-      sortOrder: 0,
+      sortOrder,
       name: input.name,
+      status: "Draft",
       updatedAt: /* @__PURE__ */ new Date(),
       createdAt: /* @__PURE__ */ new Date(),
       createdByUserId: this.userId
@@ -17297,6 +17336,22 @@ var LocalProjectActionExecutor = class {
       name: input.name ?? existingFeature.name,
       description: input.description ?? existingFeature.description,
       isArchived: input.isArchived ?? existingFeature.isArchived,
+      status: input.status ?? existingFeature.status,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.features.set(id, mergedFeature);
+  }
+  featureMove(trx) {
+    const { input } = trx;
+    const { id, afterId, sectionId } = input;
+    const existingFeature = this.features.get(id);
+    if (!existingFeature) {
+      throw new Error(`Cannot move feature: feature ${id} was not found in local storage`);
+    }
+    const sortOrder = this.calculateItemSortOrder(this.features, afterId, sectionId);
+    const mergedFeature = {
+      ...existingFeature,
+      sortOrder,
       updatedAt: /* @__PURE__ */ new Date()
     };
     this.features.set(id, mergedFeature);
@@ -17313,15 +17368,15 @@ var LocalProjectActionExecutor = class {
   //
   sectionCreate(trx) {
     const { input } = trx;
-    const { id } = input;
+    const { id, afterSectionId } = input;
     const sections = input.childType === "Artifact" ? this.artifactSections : this.featureSections;
+    const sortOrder = this.calculateSectionSortOrder(sections, afterSectionId);
     sections.set(id, {
       id,
       projectId: this.projectId,
       name: input.name,
       childType: input.childType,
-      sortOrder: 0,
-      // TODO: Use Roman's calculate functions
+      sortOrder,
       updatedAt: /* @__PURE__ */ new Date(),
       createdAt: /* @__PURE__ */ new Date()
     });
@@ -17341,6 +17396,22 @@ var LocalProjectActionExecutor = class {
     const sections = existingSection.childType === "Artifact" ? this.artifactSections : this.featureSections;
     sections.set(id, mergedSection);
   }
+  sectionMove(trx) {
+    const { input } = trx;
+    const { id, afterSectionId } = input;
+    const existingSection = this.artifactSections.get(id) ?? this.featureSections.get(id);
+    if (!existingSection) {
+      throw new Error(`Cannot move section: section ${id} was not found in local storage`);
+    }
+    const sections = existingSection.childType === "Artifact" ? this.artifactSections : this.featureSections;
+    const sortOrder = this.calculateSectionSortOrder(sections, afterSectionId);
+    const mergedSection = {
+      ...existingSection,
+      sortOrder,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    sections.set(id, mergedSection);
+  }
   sectionDelete(trx) {
     const { input } = trx;
     const { id } = input;
@@ -17350,6 +17421,59 @@ var LocalProjectActionExecutor = class {
       throw new Error(`Cannot delete section: section ${id} was not found in local storage`);
     }
   }
+  calculateSectionSortOrder(items, afterItemId) {
+    const sortedItems = Array.from(items.values()).sort((a, b) => a.sortOrder - b.sortOrder);
+    const sortOrder = this.calculateSortOrderNoDb(
+      (pId) => sortedItems.find((s) => s.projectId === pId),
+      (pId) => sortedItems.findLast((s) => s.projectId === pId),
+      (pId, id) => sortedItems.find((s) => s.projectId === pId && s.id === id),
+      (pId, sortOrder2) => sortedItems.find((s) => s.projectId === pId && s.sortOrder > sortOrder2),
+      (pId, sortOrder2, step) => items.forEach((s) => s.sortOrder > sortOrder2 && s.projectId === pId ? s.sortOrder += step : {}),
+      this.projectId,
+      afterItemId
+    );
+    return sortOrder ?? 0;
+  }
+  calculateItemSortOrder(items, afterItemId, sectionId) {
+    const sortedItems = Array.from(items.values()).sort((a, b) => a.sortOrder - b.sortOrder);
+    const matchIds = (i, pId, sId) => i.sectionId === sId && i.projectId === pId;
+    const sortOrder = this.calculateSortOrderNoDb(
+      (pId, sId) => sortedItems.find((i) => matchIds(i, pId, sId)),
+      (pId, sId) => sortedItems.findLast((i) => matchIds(i, pId, sId)),
+      (pId, id, sId) => sortedItems.find((i) => i.id === id && matchIds(i, pId, sId)),
+      (pId, sortOrder2, sId) => sortedItems.find((i) => i.sortOrder > sortOrder2 && matchIds(i, pId, sId)),
+      (pId, sortOrder2, step, sId) => items.forEach((i) => i.sortOrder > sortOrder2 && matchIds(i, pId, sId) ? i.sortOrder += step : {}),
+      this.projectId,
+      afterItemId,
+      sectionId ?? void 0
+    );
+    return sortOrder ?? 0;
+  }
+  // See also calculateSectionSortOrder and calculateSectionedItemSortOrder
+  calculateSortOrderNoDb(findFirst, findLast, findUnique, findNext, shiftAfter, projectId, afterItemId, sectionId) {
+    const SORT_ORDER_STEP = 1e3;
+    if (afterItemId === void 0) {
+      const lastSection = findLast(projectId, sectionId);
+      return (lastSection?.sortOrder ?? 0) + SORT_ORDER_STEP;
+    } else if (afterItemId === null) {
+      const firstSection = findFirst(projectId, sectionId);
+      return (firstSection?.sortOrder ?? SORT_ORDER_STEP) - SORT_ORDER_STEP;
+    } else {
+      const targetSection = findUnique(projectId, afterItemId, sectionId);
+      if (!targetSection) return null;
+      const nextSection = findNext(projectId, targetSection.sortOrder, sectionId);
+      if (nextSection) {
+        let newSortOrder = Math.floor((targetSection.sortOrder + nextSection.sortOrder) / 2);
+        if (newSortOrder <= targetSection.sortOrder) {
+          newSortOrder = targetSection.sortOrder + SORT_ORDER_STEP / 2;
+          shiftAfter(projectId, targetSection.sortOrder, SORT_ORDER_STEP, sectionId);
+        }
+        return newSortOrder;
+      } else {
+        return targetSection.sortOrder + SORT_ORDER_STEP;
+      }
+    }
+  }
 };
 
 // src/sync/project-content-repo.ts
@@ -17568,6 +17692,7 @@ export {
   DTOCreateForgeProjectResponse,
   DTOCreateForgeSpecArtifact,
   DTOCreateVersionInput,
+  DTOCreditBalance,
   DTODataSource,
   DTODataSourceFigma,
   DTODataSourceFigmaCloud,