@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/portal/portal-settings.ts

@@ -0,0 +1,45 @@
+import {
+  PortalSettingsSidebar,
+  PortalSettingsSidebarLink,
+  PortalSettingsSidebarSection,
+  PortalSettingsTheme,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOPortalSettingsTheme = PortalSettingsTheme;
+export const DTOPortalSettingsSidebarLink = PortalSettingsSidebarLink;
+export const DTOPortalSettingsSidebarSection = PortalSettingsSidebarSection;
+export const DTOPortalSettingsSidebar = PortalSettingsSidebar;
+
+export const DTOPortalSettings = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+
+  enabledDesignSystemIds: z.array(z.string()),
+  enabledBrandPersistentIds: z.array(z.string()),
+
+  theme: DTOPortalSettingsTheme.nullish(),
+  sidebar: DTOPortalSettingsSidebar.nullish(),
+
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const DTOPortalSettingsGetResponse = z.object({
+  portalSettings: DTOPortalSettings,
+});
+
+export const DTOPortalSettingsUpdatePayload = z.object({
+  enabledDesignSystemIds: z.array(z.string()).optional(),
+  enabledBrandPersistentIds: z.array(z.string()).optional(),
+  theme: DTOPortalSettingsTheme.nullish(),
+  sidebar: DTOPortalSettingsSidebar.nullish(),
+});
+
+export type DTOPortalSettingsTheme = z.infer<typeof DTOPortalSettingsTheme>;
+export type DTOPortalSettingsSidebarLink = z.infer<typeof DTOPortalSettingsSidebarLink>;
+export type DTOPortalSettingsSidebarSection = z.infer<typeof DTOPortalSettingsSidebarSection>;
+export type DTOPortalSettingsSidebar = z.infer<typeof DTOPortalSettingsSidebar>;
+export type DTOPortalSettings = z.infer<typeof DTOPortalSettings>;
+export type DTOPortalSettingsGetResponse = z.infer<typeof DTOPortalSettingsGetResponse>;
+export type DTOPortalSettingsUpdatePayload = z.infer<typeof DTOPortalSettingsUpdatePayload>;

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

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

package/src/api/dto/sandboxes/template.ts

@@ -0,0 +1,143 @@
+import z from "zod";
+
+//
+// Entity
+//
+
+export const DTOSandboxTemplatePreset = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  thumbnailUrl: z.string().optional(),
+  files: z.string().array(),
+});
+
+export const DTOSandboxTemplateVersion = z.object({
+  name: z.string(),
+  createdAt: z.string(),
+  createdByUserId: z.string(),
+  e2bTemplateId: z.string(),
+  templates: DTOSandboxTemplatePreset.array().optional(),
+  hasDesignModePlugin: z.boolean().optional(),
+});
+
+export const DTOSandboxTemplate = z.object({
+  id: z.string(),
+  name: z.string(),
+  workspaceId: z.string(),
+  designSystemId: z.string(),
+  createdAt: z.string(),
+  versions: DTOSandboxTemplateVersion.array(),
+});
+
+export const DTOSandboxTemplateBuild = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  designSystemId: z.string(),
+  name: z.string(),
+  version: z.string(),
+  createdAt: z.string(),
+  finishedAt: z.string().optional(),
+  createdByUserId: z.string(),
+  /** @deprecated use `dockerImageUri` instead */
+  dockerImagePath: z.string().optional(),
+  dockerImageUri: z.string(),
+  error: z.string().optional(),
+  state: z.enum(["PendingUpload", "Building", "Success", "Failure", "Timeout"]),
+});
+
+export const DTOSandboxTemplateFile = z.object({
+  key: z.string(),
+  fileId: z.string(),
+  filePath: z.string(),
+  url: z.string(),
+});
+
+export const DTOSandboxTemplateVersionDetail = z.object({
+  version: DTOSandboxTemplateVersion,
+  files: DTOSandboxTemplateFile.array(),
+});
+
+export type DTOSandboxTemplate = z.infer<typeof DTOSandboxTemplate>;
+export type DTOSandboxTemplatePreset = z.infer<typeof DTOSandboxTemplatePreset>;
+export type DTOSandboxTemplateVersion = z.infer<typeof DTOSandboxTemplateVersion>;
+export type DTOSandboxTemplateBuild = z.infer<typeof DTOSandboxTemplateBuild>;
+export type DTOSandboxTemplateFile = z.infer<typeof DTOSandboxTemplateFile>;
+export type DTOSandboxTemplateVersionDetail = z.infer<typeof DTOSandboxTemplateVersionDetail>;
+
+//
+// Read
+//
+
+export const DTOSandboxTemplateQuery = z.object({
+  workspaceId: z.string(),
+  designSystemId: z.string().optional(),
+});
+
+export const DTOSandboxTemplateListResponse = z.object({
+  templates: DTOSandboxTemplate.array(),
+});
+
+export const DTOSandboxTemplateResponse = z.object({
+  template: DTOSandboxTemplate,
+});
+
+export const DTOSandboxTemplateBuildResponse = z.object({
+  build: DTOSandboxTemplateBuild,
+});
+
+export type DTOSandboxTemplateQuery = z.infer<typeof DTOSandboxTemplateQuery>;
+export type DTOSandboxTemplateListResponse = z.infer<typeof DTOSandboxTemplateListResponse>;
+export type DTOSandboxTemplateResponse = z.infer<typeof DTOSandboxTemplateResponse>;
+export type DTOSandboxTemplateBuildResponse = z.infer<typeof DTOSandboxTemplateBuildResponse>;
+
+//
+// Write
+//
+
+export const DTOSandboxTemplateBuildCreateInput = z.object({
+  workspaceId: z.string(),
+  designSystemId: z.string(),
+  name: z.string(),
+  version: z.string(),
+  isExistingVersionUpdateAllowed: z.boolean(),
+  hasDesignModePlugin: z.boolean().optional(),
+  dockerImageUri: z.string().optional(),
+  customAuth: z.object({ username: z.string(), password: z.string() }).optional(),
+  templates: z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      description: z.string(),
+      thumbnailUrl: z.string().optional(),
+      files: z.string().array(),
+    })
+    .array()
+    .optional(),
+});
+
+export const DTOSandboxTemplateBuildTriggerInput = z.object({
+  imageFileId: z.string().optional(),
+});
+
+export const DTOSandboxTemplateBuildCreateResponse = z.object({
+  /** @deprecated use build.dockerImageUri */
+  dockerUrl: z.string().optional(),
+
+  /** @deprecated use build.dockerImageUri */
+  dockerRegistryDomain: z.string().optional(),
+
+  /** @deprecated use docker-login endpoint */
+  dockerAccessToken: z.string().optional(),
+
+  build: DTOSandboxTemplateBuild,
+});
+
+export const DTOSandboxTemplateBuildFinalizeResponse = z.object({
+  ok: z.boolean(),
+});
+
+export type DTOSandboxTemplateBuildCreateInput = z.infer<typeof DTOSandboxTemplateBuildCreateInput>;
+export type DTOSandboxTemplateBuildTriggerInput = z.infer<typeof DTOSandboxTemplateBuildTriggerInput>;
+export type DTOSandboxTemplateBuildCreateResponse = z.infer<typeof DTOSandboxTemplateBuildCreateResponse>;
+export type DTOSandboxTemplateBuildFinalizeResponse = z.infer<typeof DTOSandboxTemplateBuildFinalizeResponse>;

package/src/api/dto/storybook-sites/index.ts

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

package/src/api/dto/storybook-sites/storybook-sites.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+
+//
+// Entity
+//
+
+export const DTOStorybookUploadStatus = z.enum(["PendingUpload", "Failed", "InProgress", "Completed", "Timeout"]);
+
+export const DTOStorybookSiteVersion = z.object({
+  id: z.string(),
+  isPublic: z.boolean(),
+  createdAt: z.string(),
+  uploadStatus: DTOStorybookUploadStatus,
+});
+
+export const DTOStorybookSite = z.object({
+  id: z.string(),
+  designSystemId: z.string(),
+  name: z.string(),
+  indexPageUrl: z.string(),
+  createdAt: z.string(),
+  currentVersion: DTOStorybookSiteVersion,
+});
+
+export type DTOStorybookUploadStatus = z.infer<typeof DTOStorybookUploadStatus>;
+export type DTOStorybookSiteVersion = z.infer<typeof DTOStorybookSiteVersion>;
+export type DTOStorybookSite = z.infer<typeof DTOStorybookSite>;
+
+//
+// Payloads
+//
+
+export const DTOStorybookSiteListQuery = z.object({
+  designSystemId: z.string(),
+});
+
+export const DTOStorybookSiteListResponse = z.object({
+  sites: DTOStorybookSite.array(),
+});
+
+export const DTOStorybookSiteUploadPayload = z.object({
+  designSystemId: z.string(),
+  isPublic: z.boolean(),
+  name: z.string(),
+});
+
+export const DTOStorybookSiteUploadResponse = z.object({
+  storybookSiteVersion: DTOStorybookSiteVersion,
+  uploadUrl: z.string(),
+});
+
+export const DTOStorybookSiteVersionResponse = z.object({
+  storybookSiteVersion: DTOStorybookSiteVersion,
+});
+
+export type DTOStorybookSiteListQuery = z.infer<typeof DTOStorybookSiteListQuery>;
+export type DTOStorybookSiteListResponse = z.infer<typeof DTOStorybookSiteListResponse>;
+export type DTOStorybookSiteUploadPayload = z.infer<typeof DTOStorybookSiteUploadPayload>;
+export type DTOStorybookSiteUploadResponse = z.infer<typeof DTOStorybookSiteUploadResponse>;
+export type DTOStorybookSiteVersionResponse = z.infer<typeof DTOStorybookSiteVersionResponse>;

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

@@ -0,0 +1,2 @@
+export * from "./override";
+export * from "./theme";

package/src/api/dto/themes/override.ts

@@ -0,0 +1,27 @@
+import { DesignTokenTypedData, ThemeOverrideOrigin } from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTOThemeOverride = DesignTokenTypedData.and(
+  z.object({
+    tokenPersistentId: z.string(),
+    origin: ThemeOverrideOrigin.optional(),
+  })
+);
+
+export type DTOThemeOverride = z.infer<typeof DTOThemeOverride>;
+
+//
+// Write
+//
+
+export const DTOThemeOverrideCreatePayload = DesignTokenTypedData.and(
+  z.object({
+    tokenPersistentId: z.string(),
+  })
+);
+
+export type DTOThemeOverrideCreatePayload = z.infer<typeof DTOThemeOverrideCreatePayload>;

package/src/api/dto/themes/theme.ts

@@ -0,0 +1,53 @@
+import { ObjectMeta } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOThemeOverride } from "./override";
+
+//
+// Read
+//
+
+export const DTOThemesListQuery = z.object({
+  brandId: z.string().optional(),
+});
+
+export const DTOTheme = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+  brandId: z.string(),
+
+  meta: ObjectMeta,
+  codeName: z.string(),
+
+  parentPersistentId: z.string().optional(),
+  collectionPersistentIds: z.string().array(),
+
+  overrides: DTOThemeOverride.array(),
+});
+
+export const DTOThemeResponse = z.object({
+  theme: DTOTheme,
+});
+
+export const DTOThemeListResponse = z.object({
+  themes: DTOTheme.array(),
+});
+
+export type DTOThemesListQuery = z.infer<typeof DTOThemesListQuery>;
+export type DTOTheme = z.infer<typeof DTOTheme>;
+export type DTOThemeResponse = z.infer<typeof DTOThemeResponse>;
+export type DTOThemeListResponse = z.infer<typeof DTOThemeListResponse>;
+
+//
+// Write
+//
+
+export const DTOThemeCreatePayload = z.object({
+  meta: ObjectMeta,
+  persistentId: z.string(),
+  brandId: z.string(),
+  codeName: z.string(),
+  overrides: DTOThemeOverride.array(),
+});
+
+export type DTOThemeCreatePayload = z.infer<typeof DTOThemeCreatePayload>;

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

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

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

@@ -0,0 +1,280 @@
+import { Id } from "@supernova-studio/model";
+import z from "zod";
+import { DTOFileReference } from "../files";
+import { DTOForgeFigmaNode } from "../forge";
+import { DTOBillingUsageSummary } from "../workspaces";
+
+//
+// Enums
+//
+
+export const DTOThreadSubjectType = z.enum(["ForgeDocument", "ForgeFeature"]);
+export const DTOThreadAgentType = z.enum(["Ask", "Document", "Prototype", "ReleaseNotes"]);
+export const DTOThreadPromptState = z.enum(["Success", "Timeout", "Error"]);
+
+export type DTOThreadSubjectType = z.infer<typeof DTOThreadSubjectType>;
+export type DTOThreadAgentType = z.infer<typeof DTOThreadAgentType>;
+export type DTOThreadPromptState = z.infer<typeof DTOThreadPromptState>;
+
+//
+// Data model
+//
+
+export const DTOThread = z.object({
+  id: z.string(),
+  liveblocksRoomId: z.string(),
+  defaultAgentType: DTOThreadAgentType,
+  subjectId: z.string(),
+  subjectType: DTOThreadSubjectType,
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export const DTOThreadMessageUserSender = z.object({
+  type: z.literal("User"),
+  userId: z.string(),
+});
+
+export const DTOThreadMessageAgentSender = z.object({
+  type: z.literal("Agent"),
+  agentType: DTOThreadAgentType,
+});
+
+export const DTOThreadMessageSystemSender = z.object({
+  type: z.literal("System"),
+  onBehalfOfUserId: z.string(),
+});
+
+export const DTOThreadMessageSender = z.discriminatedUnion("type", [
+  DTOThreadMessageUserSender,
+  DTOThreadMessageAgentSender,
+  DTOThreadMessageSystemSender,
+]);
+
+export const DTOThreadReaction = z.object({
+  messageId: Id,
+  userId: z.string(),
+  emoji: z.string(),
+  createdAt: z.string(),
+});
+
+export const DTOThreadMessageAttachments = z.object({
+  iterationId: Id.optional(),
+  files: DTOFileReference.array().optional(),
+  templateId: z.string().optional(),
+  figmaNodes: DTOForgeFigmaNode.array().optional(),
+});
+
+export const DTOThreadMessageAnnotation = z.object({
+  prompt: z.string(),
+  elements: z.array(
+    z.object({
+      xpath: z.string(),
+      line: z.string(),
+    })
+  ),
+});
+
+export const DTOThreadMessageAnnotations = z.array(DTOThreadMessageAnnotation);
+
+export const DTOThreadMessage = z.object({
+  id: Id,
+
+  threadId: z.string(),
+
+  /**
+   * Describes where the message came from
+   */
+  sender: DTOThreadMessageSender,
+
+  /**
+   * Content of the message
+   */
+  body: z.string(),
+
+  /**
+   * Indicates if the message was sent in the agentic mode, if so this message will cause an
+   * AI agent to generate a response and perform an action within the feature
+   */
+  isPrompt: z.boolean().optional(),
+
+  /**
+   * Indicates if the message is an attempt to retry agent message. Only available for agent messages.
+   */
+  isRetry: z.boolean().optional(),
+
+  /**
+   * Indicates if the sender requested agent to reply in a thread
+   */
+  startsNewThread: z.boolean().optional(),
+
+  /**
+   * If defined, this message is considered to be a reply in a thread under parent message id
+   */
+  parentMessageId: Id.optional(),
+
+  /**
+   * Link agent response object describing current state of
+   */
+  agentResponseTrackerId: Id.optional().nullable(),
+
+  attachments: DTOThreadMessageAttachments.optional(),
+  annotations: DTOThreadMessageAnnotations.optional(),
+
+  /**
+   * If defined, this message is considered to be a reply to different message
+   */
+  replyToMessageId: Id.optional(),
+
+  promptMetadata: z.record(z.string(), z.any()).optional(),
+
+  createdAt: z.string(),
+  updatedAt: z.string().optional(),
+});
+
+export const DTOThreadAgentResponseTracker = z.object({
+  id: Id,
+  currentBody: z.string().default(""),
+});
+
+export type DTOThread = z.infer<typeof DTOThread>;
+export type DTOThreadMessageUserSender = z.infer<typeof DTOThreadMessageUserSender>;
+export type DTOThreadMessageAgentSender = z.infer<typeof DTOThreadMessageAgentSender>;
+export type DTOThreadMessageSystemSender = z.infer<typeof DTOThreadMessageSystemSender>;
+export type DTOThreadMessageSender = z.infer<typeof DTOThreadMessageSender>;
+export type DTOThreadReaction = z.infer<typeof DTOThreadReaction>;
+export type DTOThreadMessage = z.infer<typeof DTOThreadMessage>;
+export type DTOThreadMessageAttachments = z.infer<typeof DTOThreadMessageAttachments>;
+export type DTOThreadMessageAnnotation = z.infer<typeof DTOThreadMessageAnnotation>;
+export type DTOThreadMessageAnnotations = z.infer<typeof DTOThreadMessageAnnotations>;
+export type DTOThreadAgentResponseTracker = z.infer<typeof DTOThreadAgentResponseTracker>;
+
+//
+// Payloads
+//
+
+export const DTOThreadMessageAttachmentsCreateInput = z.object({
+  iterationId: Id.optional(),
+  fileIds: z.string().array().optional(),
+  figmaNodeIds: z.string().array().optional(),
+  templateId: z.string().optional(),
+});
+
+export const DTOThreadMessageCreateInput = DTOThreadMessage.pick({
+  id: true,
+  body: true,
+  isPrompt: true,
+  startsNewThread: true,
+  parentMessageId: true,
+  promptMetadata: true,
+  annotations: true,
+}).extend({
+  attachments: DTOThreadMessageAttachmentsCreateInput.optional(),
+});
+
+export const DTOThreadMessageFinalizeInput = z.object({
+  messageId: Id,
+  agentMessageBody: z.string().optional(),
+  promptState: DTOThreadPromptState.optional(),
+  billingUsageSummary: DTOBillingUsageSummary.optional(),
+});
+
+export const DTOThreadMessageRetryInput = z.object({
+  agentMessageId: Id,
+  runtimeError: z.string().optional(),
+  /**
+   * When `true`, the retry message will be sent to a thread started by the user's message
+   * Useful when user retries a message created in the main thread, but expects the retry to be sent as a thread reply
+   */
+  shouldReplyInThread: z.boolean().optional(),
+  message: DTOThreadMessage.pick({ id: true, body: true }).optional(),
+});
+
+export const DTOThreadMessageUpdateInput = DTOThreadMessage.pick({
+  id: true,
+}).merge(
+  z
+    .object({
+      body: DTOThreadMessage.shape.body,
+      attachments: DTOThreadMessage.shape.attachments,
+      agentResponseTrackerId: DTOThreadMessage.shape.agentResponseTrackerId.nullable(),
+    })
+    .partial()
+);
+
+export const DTOThreadReactionCreateInput = z.object({
+  messageId: Id,
+  emoji: z.string(),
+});
+
+export const DTOThreadReactionDeleteInput = z.object({
+  messageId: Id,
+  emoji: z.string(),
+});
+
+export type DTOThreadMessageAttachmentsCreateInput = z.infer<typeof DTOThreadMessageAttachmentsCreateInput>;
+export type DTOThreadMessageFinalizeInput = z.infer<typeof DTOThreadMessageFinalizeInput>;
+export type DTOThreadMessageRetryInput = z.infer<typeof DTOThreadMessageRetryInput>;
+export type DTOThreadMessageCreateInput = z.infer<typeof DTOThreadMessageCreateInput>;
+export type DTOThreadMessageUpdateInput = z.infer<typeof DTOThreadMessageUpdateInput>;
+export type DTOThreadReactionDeleteInput = z.infer<typeof DTOThreadReactionDeleteInput>;
+export type DTOThreadReactionCreateInput = z.infer<typeof DTOThreadReactionCreateInput>;
+
+//
+// Responses
+//
+
+export const DTOThreadMessageResponse = z.object({
+  message: DTOThreadMessage,
+});
+
+export const DTOThreadReactionResponse = z.object({
+  reaction: DTOThreadReaction,
+});
+
+export const DTOThreadMessageListResponse = z.object({
+  messages: DTOThreadMessage.array(),
+  reactions: DTOThreadReaction.array(),
+  lastSeenMessageId: z.string().optional(),
+});
+
+export type DTOThreadMessageResponse = z.infer<typeof DTOThreadMessageResponse>;
+export type DTOThreadReactionResponse = z.infer<typeof DTOThreadReactionResponse>;
+export type DTOThreadMessageListResponse = z.infer<typeof DTOThreadMessageListResponse>;
+
+//
+// Events
+//
+
+export const DTOThreadEventMessagesSent = z.object({
+  type: z.literal("MessagesSent"),
+  data: DTOThreadMessage.array(),
+});
+
+export const DTOThreadEventMessagesUpdated = z.object({
+  type: z.literal("MessagesUpdated"),
+  data: DTOThreadMessage.array(),
+});
+
+export const DTOThreadEventReactionsSent = z.object({
+  type: z.literal("ReactionsSent"),
+  data: DTOThreadReaction.array(),
+});
+
+export const DTOThreadEventReactionsDeleted = z.object({
+  type: z.literal("ReactionsDeleted"),
+  data: DTOThreadReaction.array(),
+});
+
+export const DTOThreadEvent = z.discriminatedUnion("type", [
+  DTOThreadEventMessagesSent,
+  DTOThreadEventMessagesUpdated,
+  DTOThreadEventReactionsSent,
+  DTOThreadEventReactionsDeleted,
+]);
+
+export type DTOThreadEventMessagesSent = z.infer<typeof DTOThreadEventMessagesSent>;
+export type DTOThreadEventMessagesUpdated = z.infer<typeof DTOThreadEventMessagesUpdated>;
+export type DTOThreadEventReactionsSent = z.infer<typeof DTOThreadEventReactionsSent>;
+export type DTOThreadEventReactionsDeleted = z.infer<typeof DTOThreadEventReactionsDeleted>;
+export type DTOThreadEvent = z.infer<typeof DTOThreadEvent>;

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

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