@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/trail-events/trail-events.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+
+export const DTOTrailEventType = z.enum([
+  "IterationCreated",
+  "IterationBookmarked",
+  "FeatureCreated",
+  "FeatureDeleted",
+  "FeatureArchived",
+  "DocumentCreated",
+  "DocumentDeleted",
+  "DocumentUpdated",
+  "DocumentCommentSent",
+  "ProjectCreated",
+  "ProjectArchived",
+  "IterationPromoted",
+  "ProjectContextCreated",
+  "ProjectContextArchived",
+  "FeaturePublished",
+  "FeatureUnpublished",
+]);
+
+const DTOTrailEventBase = z.object({
+  id: z.string(),
+  projectId: z.string(),
+  userId: z.string(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+const DTOTrailEventIterationCreatedPayload = z.object({
+  iterationName: z.string(),
+  iterationId: z.string().uuid(),
+  featureId: z.string().uuid(),
+});
+
+const DTOTrailEventIterationBookmarkedPayload = z.object({
+  iterationId: z.string().uuid(),
+  featureId: z.string().uuid(),
+  iterationName: z.string(),
+});
+
+const DTOTrailEventIterationPromotedPayload = z.object({
+  iterationId: z.string().uuid(),
+  featureId: z.string().uuid(),
+  iterationName: z.string(),
+});
+
+const DTOTrailEventFeatureCreatedPayload = z.object({
+  featureId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().optional(),
+});
+
+const DTOTrailEventFeatureDeletedPayload = z.object({
+  featureId: z.string().uuid(),
+  name: z.string(),
+});
+
+const DTOTrailEventFeatureArchivedPayload = z.object({
+  featureId: z.string().uuid(),
+  name: z.string(),
+});
+
+const DTOTrailEventDocumentCreatedPayload = z.object({
+  documentId: z.string().uuid(),
+  title: z.string(),
+  sectionId: z.string().uuid().optional(),
+});
+
+const DTOTrailEventDocumentDeletedPayload = z.object({
+  documentId: z.string().uuid(),
+  title: z.string(),
+});
+
+const DTOTrailEventDocumentUpdatedPayload = z.object({
+  documentId: z.string().uuid(),
+  title: z.string(),
+  sectionId: z.string().uuid().optional(),
+});
+
+const DTOTrailEventDocumentCommentSentPayload = z.object({
+  documentId: z.string().uuid(),
+  title: z.string(),
+  sectionId: z.string().uuid().optional(),
+});
+
+const DTOTrailEventProjectCreatedPayload = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+});
+
+const DTOTrailEventFeaturePublishedPayload = z.object({
+  featureId: z.string().uuid(),
+  featureName: z.string(),
+  iterationId: z.string().uuid().nullish(),
+  iterationName: z.string().nullish(),
+});
+
+const DTOTrailEventFeatureUnpublishedPayload = z.object({
+  featureId: z.string().uuid(),
+  featureName: z.string(),
+  iterationId: z.string().uuid().nullish(),
+  iterationName: z.string().nullish(),
+});
+
+const DTOTrailEventProjectArchivedPayload = z.object({
+  name: z.string(),
+});
+
+const DTOTrailEventProjectContextCreatedPayload = z.object({
+  contextId: z.number(),
+  name: z.string(),
+  description: z.string().optional(),
+});
+
+const DTOTrailEventProjectContextArchivedPayload = z.object({
+  contextId: z.number(),
+});
+
+const DTOTrailEventPayload = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("IterationCreated"), payload: DTOTrailEventIterationCreatedPayload }),
+  z.object({ type: z.literal("IterationBookmarked"), payload: DTOTrailEventIterationBookmarkedPayload }),
+  z.object({ type: z.literal("FeatureCreated"), payload: DTOTrailEventFeatureCreatedPayload }),
+  z.object({ type: z.literal("FeatureDeleted"), payload: DTOTrailEventFeatureDeletedPayload }),
+  z.object({ type: z.literal("FeatureArchived"), payload: DTOTrailEventFeatureArchivedPayload }),
+  z.object({ type: z.literal("DocumentCreated"), payload: DTOTrailEventDocumentCreatedPayload }),
+  z.object({ type: z.literal("DocumentDeleted"), payload: DTOTrailEventDocumentDeletedPayload }),
+  z.object({ type: z.literal("DocumentUpdated"), payload: DTOTrailEventDocumentUpdatedPayload }),
+  z.object({ type: z.literal("DocumentCommentSent"), payload: DTOTrailEventDocumentCommentSentPayload }),
+  z.object({ type: z.literal("ProjectCreated"), payload: DTOTrailEventProjectCreatedPayload }),
+  z.object({ type: z.literal("ProjectArchived"), payload: DTOTrailEventProjectArchivedPayload }),
+  z.object({ type: z.literal("IterationPromoted"), payload: DTOTrailEventIterationPromotedPayload }),
+  z.object({ type: z.literal("ProjectContextCreated"), payload: DTOTrailEventProjectContextCreatedPayload }),
+  z.object({ type: z.literal("ProjectContextArchived"), payload: DTOTrailEventProjectContextArchivedPayload }),
+  z.object({ type: z.literal("FeaturePublished"), payload: DTOTrailEventFeaturePublishedPayload }),
+  z.object({ type: z.literal("FeatureUnpublished"), payload: DTOTrailEventFeatureUnpublishedPayload }),
+]);
+
+export const DTOTrailEvent = DTOTrailEventPayload.and(DTOTrailEventBase);
+
+export const DTOTrailEventWithDetails = DTOTrailEvent.and(
+  z.object({
+    projectName: z.string().optional(),
+    userName: z.string().optional(),
+  })
+);
+
+export const DTOTrailEventListInput = z.object({
+  projectId: z.string(),
+});
+
+export const DTOTrailEventListResponse = z.object({
+  events: z.array(DTOTrailEventWithDetails),
+});
+
+export const DTOTrailEventCreate = DTOTrailEventPayload.and(
+  DTOTrailEventBase.omit({ id: true, createdAt: true, updatedAt: true })
+);
+
+export const DTOTrailEventClientCreate = z
+  .discriminatedUnion("type", [
+    z.object({ type: z.literal("DocumentUpdated"), payload: DTOTrailEventDocumentUpdatedPayload }),
+    z.object({ type: z.literal("DocumentCommentSent"), payload: DTOTrailEventDocumentCommentSentPayload }),
+  ])
+  .and(DTOTrailEventBase.omit({ id: true, createdAt: true, updatedAt: true }));
+
+export type DTOTrailEvent = z.infer<typeof DTOTrailEvent>;
+export type DTOTrailEventWithDetails = z.infer<typeof DTOTrailEventWithDetails>;
+export type DTOTrailEventListInput = z.infer<typeof DTOTrailEventListInput>;
+export type DTOTrailEventListResponse = z.infer<typeof DTOTrailEventListResponse>;
+export type DTOTrailEventType = z.infer<typeof DTOTrailEventType>;
+export type DTOTrailEventCreate = z.infer<typeof DTOTrailEventCreate>;

package/src/api/dto/users/authenticated-user.ts

@@ -0,0 +1,92 @@
+import {
+  PortalTheme,
+  UserOnboardingDepartment,
+  UserOnboardingJobLevel,
+  UserSource,
+  UserTheme,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOUser, DTOUserProfile } from "./user";
+
+//
+// Entities
+//
+
+export const DTOUserOnboardingDepartment = UserOnboardingDepartment;
+export const DTOUserOnboardingJobLevel = UserOnboardingJobLevel;
+export const DTOUserSource = UserSource;
+export const DTOUserTheme = UserTheme;
+export const DTOUserPortalTheme = PortalTheme;
+
+export const DTOUserOnboarding = z.object({
+  companyName: z.string().optional(),
+  numberOfPeopleInOrg: z.string().optional(),
+  numberOfPeopleInDesignTeam: z.string().optional(),
+  department: DTOUserOnboardingDepartment.optional(),
+  jobTitle: z.string().optional(),
+  phase: z.string().optional(),
+  jobLevel: DTOUserOnboardingJobLevel.optional(),
+  designSystemName: z.string().optional(),
+  defaultDestination: z.string().optional(),
+  isPageDraftOnboardingFinished: z.boolean().optional(),
+  figmaUrl: z.string().optional(),
+  isApprovalsOnboardingFinished: z.boolean().optional(),
+});
+
+export const DTOAuthenticatedUserProfile = DTOUserProfile.extend({
+  onboarding: DTOUserOnboarding.optional(),
+  theme: DTOUserTheme.optional(),
+  portalTheme: DTOUserPortalTheme.optional(),
+});
+
+export const DTOUserEmailSettings = z.object({
+  marketingEmails: z.boolean(),
+});
+
+export const DTOAuthenticatedUser = DTOUser.extend({
+  profile: DTOAuthenticatedUserProfile,
+  emailSettings: DTOUserEmailSettings,
+  createdAt: z.coerce.date(),
+  loggedOutAt: z.coerce.date().optional(),
+  source: DTOUserSource.optional(),
+});
+
+export type DTOUserOnboardingDepartment = z.infer<typeof DTOUserOnboardingDepartment>;
+export type DTOUserOnboardingJobLevel = z.infer<typeof DTOUserOnboardingJobLevel>;
+export type DTOUserSource = z.infer<typeof DTOUserSource>;
+export type DTOUserTheme = z.infer<typeof DTOUserTheme>;
+export type DTOUserPortalTheme = z.infer<typeof DTOUserPortalTheme>;
+export type DTOUserOnboarding = z.infer<typeof DTOUserOnboarding>;
+export type DTOAuthenticatedUserProfile = z.infer<typeof DTOAuthenticatedUserProfile>;
+export type DTOUserEmailSettings = z.infer<typeof DTOUserEmailSettings>;
+export type DTOAuthenticatedUser = z.infer<typeof DTOAuthenticatedUser>;
+
+//
+// Payloads - input
+//
+
+export const DTOUserProfileUpdatePayload = DTOAuthenticatedUserProfile.partial().omit({
+  avatar: true,
+});
+
+export const DTOUserEmailSettingsUpdatePayload = DTOUserEmailSettings.partial();
+
+export const DTOUserUpdatePayload = z.object({
+  profile: DTOUserProfileUpdatePayload.optional(),
+  emailSettings: DTOUserEmailSettingsUpdatePayload.optional(),
+  avatarFileId: z.string().optional(),
+});
+
+export type DTOUserProfileUpdatePayload = z.infer<typeof DTOUserProfileUpdatePayload>;
+export type DTOUserEmailSettingsUpdatePayload = z.infer<typeof DTOUserEmailSettingsUpdatePayload>;
+export type DTOUserUpdatePayload = z.infer<typeof DTOUserUpdatePayload>;
+
+//
+// Payloads - output
+//
+
+export const DTOAuthenticatedUserResponse = z.object({
+  user: DTOAuthenticatedUser,
+});
+
+export type DTOAuthenticatedUserResponse = z.infer<typeof DTOAuthenticatedUserResponse>;

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

@@ -0,0 +1,2 @@
+export * from "./authenticated-user";
+export * from "./user";

package/src/api/dto/users/user.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+/**
+ * Definition of a user profile as inspectable by other users (i.e. reduced version)
+ */
+export const DTOUserProfile = z.object({
+  name: z.string(),
+  nickname: z.string().optional(),
+  avatar: z.string().optional(),
+});
+
+/**
+ * Definition of a user as inspectable by other users (i.e. reduced version)
+ */
+export const DTOUser = z.object({
+  id: z.string(),
+  email: z.string(),
+  profile: DTOUserProfile,
+});
+
+export const DTOUserGetResponse = z.object({
+  user: DTOUser,
+});
+
+export type DTOUserProfile = z.infer<typeof DTOUserProfile>;
+export type DTOUser = z.infer<typeof DTOUser>;
+export type DTOUserGetResponse = z.infer<typeof DTOUserGetResponse>;

package/src/api/dto/workspaces/billing.ts

@@ -0,0 +1,156 @@
+import z from "zod";
+import { DTOBillingInterval, DTOProductCode } from "./enums";
+
+export const DTOBillingSupportedModels = z.enum([
+  "GPT_4_1",
+  "GPT_4_1_MINI",
+  "GPT_4O",
+  "O1",
+  "GPT_5",
+  "GPT_5_MINI",
+  "GPT_5_NANO",
+  "GPT_5_2_CODEX",
+  "GPT_5_3_CODEX",
+  "GPT_5_4",
+  "GPT_5_5",
+  // Claude models
+  "CLAUDE_OPUS_4_0",
+  "CLAUDE_OPUS_4_1",
+  "CLAUDE_OPUS_4_5",
+  "CLAUDE_SONNET_4_0",
+  "CLAUDE_SONNET_4_5",
+  "CLAUDE_HAIKU_4_5",
+  // Claude dated models
+  "CLAUDE_OPUS_4_20250514",
+  "CLAUDE_OPUS_4_1_20250805",
+  "CLAUDE_OPUS_4_5_20251101",
+  "CLAUDE_3_7_SONNET_20250219",
+  "CLAUDE_3_7_SONNET_LATEST",
+  "CLAUDE_SONNET_4_20250514",
+  "CLAUDE_SONNET_4_5_20250929",
+  "CLAUDE_3_HAIKU_20240307",
+  "CLAUDE_3_5_HAIKU_20241022",
+  "CLAUDE_3_5_HAIKU_LATEST",
+  "CLAUDE_HAIKU_4_5_20251001",
+]);
+
+export const DTOBillingCheckoutMode = z.enum(["SubscriptionChange", "CreditsTopUp"]);
+export const DTOBillingCreditsSpendAction = z.enum(["Ask", "Build", "DocumentUpdate"]);
+
+export type DTOBillingSupportedModels = z.infer<typeof DTOBillingSupportedModels>;
+export type DTOBillingCheckoutMode = z.infer<typeof DTOBillingCheckoutMode>;
+export type DTOBillingCreditsSpendAction = z.infer<typeof DTOBillingCreditsSpendAction>;
+
+//
+// Subscription Preview
+//
+
+export const DTOBillingSubscriptionChangePreviewInput = z.object({
+  plan: DTOProductCode,
+  interval: DTOBillingInterval,
+  fullSeats: z.number(),
+  builderSeats: z.number(),
+  additionalCredits: z.number(),
+});
+
+export type DTOBillingSubscriptionChangePreviewInput = z.infer<typeof DTOBillingSubscriptionChangePreviewInput>;
+
+//
+// Credits Spend
+//
+
+export const DTOBillingCreditsSpendInput = z.object({
+  inputTokenCount: z.number().int().nonnegative(),
+  outputTokenCount: z.number().int().nonnegative(),
+  inputCachedTokenCount: z.number().int().nonnegative().optional(),
+  modelName: DTOBillingSupportedModels,
+  action: DTOBillingCreditsSpendAction.optional().default(DTOBillingCreditsSpendAction.enum.Ask),
+});
+
+export const DTOBillingUsageEntry = z.object({
+  executionId: z.string(),
+  parentExecutionId: z.string().optional(),
+  executionKind: z.enum(["root", "subagent"]),
+  agent: z.string(),
+  modelName: DTOBillingSupportedModels,
+  providerRequestId: z.string().optional(),
+  inputTokenCount: z.number().int().nonnegative(),
+  outputTokenCount: z.number().int().nonnegative(),
+  inputCachedTokenCount: z.number().int().nonnegative().optional(),
+  reasoningTokenCount: z.number().int().nonnegative().optional(),
+});
+
+export const DTOBillingUsageSummary = z.object({
+  rootAction: DTOBillingCreditsSpendAction,
+  entries: z.array(DTOBillingUsageEntry),
+});
+
+export const DTOBillingCreditsSpendResponse = z.object({
+  hasOverspend: z.boolean(),
+});
+
+export const DTOBillingCreditsCheckIfCanSpendResponse = z.object({
+  canSpendCredits: z.boolean(),
+});
+
+export type DTOBillingCreditsSpendInput = z.infer<typeof DTOBillingCreditsSpendInput>;
+export type DTOBillingUsageEntry = z.infer<typeof DTOBillingUsageEntry>;
+export type DTOBillingUsageSummary = z.infer<typeof DTOBillingUsageSummary>;
+export type DTOBillingCreditsSpendResponse = z.infer<typeof DTOBillingCreditsSpendResponse>;
+export type DTOBillingCreditsCheckIfCanSpendResponse = z.infer<typeof DTOBillingCreditsCheckIfCanSpendResponse>;
+
+//
+// Checkout
+//
+
+export const DTOBillingCheckoutOldInput = z.object(
+  {
+    mode: z.literal(undefined),
+
+    successUrl: z.string().url(),
+    cancelUrl: z.string().url(),
+
+    priceId: z.string(),
+    quantity: z.number().int().min(1),
+  },
+  { description: "It is deprecated, keep for backwards compatibility" }
+);
+
+export const DTOBillingCheckoutSubscriptionChangeInput = z.object({
+  mode: z.literal(DTOBillingCheckoutMode.enum.SubscriptionChange),
+
+  successUrl: z.string().url(),
+  cancelUrl: z.string().url(),
+
+  plan: DTOProductCode,
+  interval: DTOBillingInterval,
+  fullSeats: z.number(),
+  builderSeats: z.number(),
+  additionalCredits: z.number(),
+});
+
+export const DTOBillingCheckoutCreditsTopUpInput = z.object({
+  mode: z.literal(DTOBillingCheckoutMode.enum.CreditsTopUp),
+
+  successUrl: z.string().url(),
+  cancelUrl: z.string().url(),
+
+  centAmount: z.number().int().nonnegative().min(1_000),
+});
+
+export const DTOBillingCheckoutInput = z.discriminatedUnion("mode", [
+  DTOBillingCheckoutOldInput,
+  DTOBillingCheckoutSubscriptionChangeInput,
+  DTOBillingCheckoutCreditsTopUpInput,
+]);
+
+export const DTOBillingCheckoutResponse = z.object({
+  id: z.string(),
+  url: z.string().nullish(),
+});
+
+export type DTOBillingCheckoutOldInput = z.infer<typeof DTOBillingCheckoutOldInput>;
+export type DTOBillingCheckoutSubscriptionChangeInput = z.infer<typeof DTOBillingCheckoutSubscriptionChangeInput>;
+export type DTOBillingCheckoutCreditsTopUpInput = z.infer<typeof DTOBillingCheckoutCreditsTopUpInput>;
+export type DTOBillingCheckoutInput = z.infer<typeof DTOBillingCheckoutInput>;
+export type DTOBillingCheckoutResponse = z.infer<typeof DTOBillingCheckoutResponse>;

package/src/api/dto/workspaces/enums.ts

@@ -0,0 +1,13 @@
+import z from "zod";
+
+export const DTOWorkspaceRole = z.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Contributor"]);
+export const DTOWorkspaceSeatType = z.enum(["Full", "Builder", "None"]);
+export const DTOWorkspaceBilledSeatType = z.enum(["Full", "Builder"]);
+export const DTOBillingInterval = z.enum(["daily", "monthly", "yearly"]);
+export const DTOProductCode = z.enum(["free", "pro", "team", "company", "enterprise"]);
+
+export type DTOWorkspaceRole = z.infer<typeof DTOWorkspaceRole>;
+export type DTOWorkspaceSeatType = z.infer<typeof DTOWorkspaceSeatType>;
+export type DTOWorkspaceBilledSeatType = z.infer<typeof DTOWorkspaceBilledSeatType>;
+export type DTOBillingInterval = z.infer<typeof DTOBillingInterval>;
+export type DTOProductCode = z.infer<typeof DTOProductCode>;

package/src/api/dto/workspaces/git.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+export const DTOGitOrganization = z.object({
+  id: z.string(),
+  name: z.string(),
+  url: z.string(),
+  slug: z.string(),
+});
+export type DTOGitOrganization = z.infer<typeof DTOGitOrganization>;
+
+export const DTOGitProject = z.object({
+  id: z.string(),
+  name: z.string(),
+  url: z.string(),
+  slug: z.string(),
+});
+export type DTOGitProject = z.infer<typeof DTOGitProject>;
+
+export const DTOGitRepository = z.object({
+  id: z.string(),
+  name: z.string(),
+  url: z.string(),
+  slug: z.string(),
+  defaultBranch: z.string().optional(),
+});
+export type DTOGitRepository = z.infer<typeof DTOGitRepository>;
+
+export const DTOGitBranch = z.object({
+  name: z.string(),
+  lastCommitId: z.string(),
+});
+export type DTOGitBranch = z.infer<typeof DTOGitBranch>;

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

@@ -0,0 +1,15 @@
+export * from "./billing";
+export * from "./enums";
+export * from "./git";
+export * from "./integrations";
+export * from "./invitations";
+export * from "./ip-whitelist";
+export * from "./knowledge-items-search";
+export * from "./login-screen";
+export * from "./membership";
+export * from "./npm-registry";
+export * from "./products";
+export * from "./subscription";
+export * from "./transfer-ownership";
+export * from "./untyped-data";
+export * from "./workspace";

package/src/api/dto/workspaces/integrations.ts

@@ -0,0 +1,34 @@
+import { ExtendedIntegrationType, IntegrationCredentials, IntegrationDesignSystem } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOIntegrationCredentials = IntegrationCredentials.omit({
+  accessToken: true,
+  refreshToken: true,
+});
+
+export const DTOIntegration = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  type: ExtendedIntegrationType,
+  createdAt: z.coerce.date(),
+  integrationCredentials: z.array(DTOIntegrationCredentials).optional(),
+  integrationDesignSystems: z.array(IntegrationDesignSystem).optional(),
+});
+
+export const DTOIntegrationOAuthGetResponse = z.object({
+  url: z.string(),
+});
+
+export const DTOIntegrationPostResponse = z.object({
+  integration: DTOIntegration,
+});
+
+export const DTOIntegrationsGetListResponse = z.object({
+  integrations: DTOIntegration.array(),
+});
+
+export type DTOIntegration = z.infer<typeof DTOIntegration>;
+export type DTOIntegrationCredentials = z.infer<typeof DTOIntegrationCredentials>;
+export type DTOIntegrationOAuthGetResponse = z.infer<typeof DTOIntegrationOAuthGetResponse>;
+export type DTOIntegrationPostResponse = z.infer<typeof DTOIntegrationPostResponse>;
+export type DTOIntegrationsGetListResponse = z.infer<typeof DTOIntegrationsGetListResponse>;

package/src/api/dto/workspaces/invitations.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { DTOWorkspaceRole, DTOWorkspaceSeatType } from "./enums";
+
+export const DTOWorkspaceInvitation = z.object({
+  id: z.string(),
+  email: z.string().email(),
+  createdAt: z.coerce.date(),
+  resentAt: z.coerce.date().nullish(),
+  role: DTOWorkspaceRole,
+  seatType: DTOWorkspaceSeatType,
+  workspaceId: z.string(),
+  invitedBy: z.string(),
+  effectiveRole: DTOWorkspaceRole,
+  effectiveSeatType: DTOWorkspaceSeatType,
+});
+
+export const DTOWorkspaceInvitationInput = z.object({
+  email: z.string().email(),
+  role: DTOWorkspaceRole,
+  seatType: DTOWorkspaceSeatType.optional(),
+  isDeveloperInvite: z.boolean().optional(),
+});
+
+export const DTOWorkspaceInvitationsListInput = z.object({
+  invites: DTOWorkspaceInvitationInput.array().max(100),
+  designSystemId: z.string().optional(),
+});
+
+export const DTOWorkspaceInvitationsResponse = z.object({
+  invitations: DTOWorkspaceInvitation.array(),
+});
+
+export const DTOWorkspaceInviteUpdate = z.object({
+  role: DTOWorkspaceRole,
+  seatType: DTOWorkspaceSeatType.optional(),
+});
+
+export const DTOWorkspaceInvitationUpdateResponse = z.object({
+  invitation: DTOWorkspaceInvitation,
+});
+
+export type DTOWorkspaceInvitation = z.infer<typeof DTOWorkspaceInvitation>;
+export type DTOWorkspaceInvitationInput = z.infer<typeof DTOWorkspaceInvitationInput>;
+export type DTOWorkspaceInvitationsListInput = z.infer<typeof DTOWorkspaceInvitationsListInput>;
+export type DTOWorkspaceInvitationsResponse = z.infer<typeof DTOWorkspaceInvitationsResponse>;
+export type DTOWorkspaceInviteUpdate = z.infer<typeof DTOWorkspaceInviteUpdate>;
+export type DTOWorkspaceInvitationUpdateResponse = z.infer<typeof DTOWorkspaceInvitationUpdateResponse>;

package/src/api/dto/workspaces/ip-whitelist.ts

@@ -0,0 +1,33 @@
+import z from "zod";
+
+//
+// Entity
+//
+
+export const DTOIPWhitelistEntry = z.object({
+  isEnabled: z.boolean(),
+  name: z.string(),
+  range: z.string().cidr(),
+});
+
+export const DTOIPWhitelist = z.object({
+  isEnabledForCloud: z.boolean(),
+  isEnabledForDocs: z.boolean(),
+  entries: DTOIPWhitelistEntry.array(),
+});
+
+export type DTOIPWhitelist = z.infer<typeof DTOIPWhitelist>;
+export type DTOIPWhitelistEntry = z.infer<typeof DTOIPWhitelistEntry>;
+
+//
+// Payloads
+//
+
+export const DTOIPWhitelistUpdate = DTOIPWhitelist.partial();
+
+export const DTOIPWhitelistResponse = z.object({
+  ipWhitelist: DTOIPWhitelist,
+});
+
+export type DTOIPWhitelistUpdate = z.infer<typeof DTOIPWhitelistUpdate>;
+export type DTOIPWhitelistResponse = z.infer<typeof DTOIPWhitelistResponse>;

package/src/api/dto/workspaces/knowledge-items-search.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const DTOKnowledgeItemSearchIndexResponse = z.object({
+  indexedItems: z.number(),
+  totalItems: z.number(),
+  skippedItems: z.number(),
+  errors: z.number(),
+});
+
+export const DTOKnowledgeItemSearchKind = z.enum(["file", "skill"]);
+
+export const DTOKnowledgeItemSearchQuery = z.object({
+  query: z.string().min(1).max(1000),
+  mode: z.enum(["full-text", "vector", "hybrid"]).optional().default("hybrid"),
+  limit: z.number().int().min(1).max(50).optional().default(10),
+  kinds: z.array(DTOKnowledgeItemSearchKind).optional(),
+});
+
+export const DTOKnowledgeItemSearchResult = z.object({
+  knowledgeItemId: z.string(),
+  kind: DTOKnowledgeItemSearchKind,
+  path: z.string(),
+  excerpt: z.string(),
+  vectorScore: z.number().nullable(),
+  fullTextScore: z.number().nullable(),
+  reciprocalRankFusionScore: z.number(),
+});
+
+export const DTOKnowledgeItemSearchResponse = z.object({
+  results: z.array(DTOKnowledgeItemSearchResult),
+});
+
+export type DTOKnowledgeItemSearchKind = z.infer<typeof DTOKnowledgeItemSearchKind>;
+export type DTOKnowledgeItemSearchIndexResponse = z.infer<typeof DTOKnowledgeItemSearchIndexResponse>;
+export type DTOKnowledgeItemSearchQuery = z.infer<typeof DTOKnowledgeItemSearchQuery>;
+export type DTOKnowledgeItemSearchResult = z.infer<typeof DTOKnowledgeItemSearchResult>;
+export type DTOKnowledgeItemSearchResponse = z.infer<typeof DTOKnowledgeItemSearchResponse>;