@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/design-systems/code-component-usage.ts

@@ -0,0 +1,52 @@
+import z from "zod";
+
+export const DTOCodeComponentPropUsage = z.object({
+  /** How many times this property has been used in this repository? */
+  usages: z.number(),
+
+  /** How many times different values have been used with this property? */
+  values: z.record(z.number()),
+
+  /** How many times a value has not been specified? (all component usages - usages with values) */
+  undefinedValue: z.number(),
+});
+
+export const DTOCodeComponentUsage = z.object({
+  /**
+   * Name of the component in its package.
+   * `componentName` and `componentPackageName` uniquely identify a component
+   */
+  componentName: z.string(),
+
+  /**
+   * Which package the component is coming from.
+   * `componentName` and `componentPackageName` uniquely identify a component
+   */
+  componentPackageName: z.string(),
+
+  /** Which repository this component is used in */
+  usageRepositoryName: z.string(),
+
+  /** Which package of the repository the component is used in */
+  usagePackageName: z.string(),
+
+  /** How many times this component has been used in this repository? */
+  usages: z.number(),
+
+  /** How many files has at least one usage of this component? */
+  usageFiles: z.number(),
+
+  /** Usage data of the component's props */
+  props: z.record(DTOCodeComponentPropUsage),
+
+  /** Timestamp of the scan that has shapshotted this data */
+  scanTimestamp: z.string(),
+});
+
+export const DTOCodeComponentUsageResponse = z.object({
+  componentUsage: DTOCodeComponentUsage.array(),
+});
+
+export type DTOCodeComponentPropUsage = z.infer<typeof DTOCodeComponentPropUsage>;
+export type DTOCodeComponentUsage = z.infer<typeof DTOCodeComponentUsage>;
+export type DTOCodeComponentUsageResponse = z.infer<typeof DTOCodeComponentUsageResponse>;

package/src/api/dto/design-systems/code-component.ts

@@ -0,0 +1,101 @@
+import z from "zod";
+
+export const DTOCodeComponentProperty = z.object({
+  name: z.string(),
+  type: z.string(),
+  isRequired: z.boolean(),
+});
+
+export const DTOCodeComponentStorybookFile = z.object({
+  name: z.string(),
+  type: z.enum(["Story", "Doc"]),
+  filePath: z.string(),
+});
+
+export const DTOCodeComponentDocFile = z.object({
+  filePath: z.string(),
+});
+
+export const DTOCodeComponent = z.object({
+  /** Stable identifier for the code component (Prisma row id, stringified). */
+  id: z.string(),
+
+  /** Name of the component in code */
+  name: z.string(),
+
+  /** Name of the package (from package.json) from where the component was imported */
+  packageName: z.string(),
+
+  /** Name of the repository that contains this component */
+  repositoryName: z.string(),
+
+  /** JSDoc comment for this component */
+  description: z.string(),
+
+  /** File path of this component, relative to the repository root */
+  filePath: z.string(),
+
+  /** All code properties of this component */
+  props: DTOCodeComponentProperty.array(),
+
+  /** List of Storybook files that mention this component */
+  storybookFiles: DTOCodeComponentStorybookFile.array(),
+
+  /** List of doc files (markdown) that mention this component */
+  docFiles: DTOCodeComponentDocFile.array(),
+
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export const DTOCodeComponentListResponse = z.object({
+  components: DTOCodeComponent.array(),
+});
+
+/** Reference to a single code component by its package and component name */
+export const DTOCodeComponentReference = z.object({
+  /** Name of the package (from package.json) the component is imported from */
+  packageName: z.string(),
+
+  /** Name of the component in code */
+  componentName: z.string(),
+});
+
+/** Request body for fetching AI-generated markdown for a batch of code components */
+export const DTOCodeComponentMarkdownQuery = z.object({
+  /** Components to fetch markdown for */
+  components: DTOCodeComponentReference.array().min(1).max(20),
+});
+
+/** AI-generated markdown detail for a single code component */
+export const DTOCodeComponentMarkdown = z.object({
+  /** Name of the component in code */
+  name: z.string(),
+
+  /** Stable key identifying the component within its package */
+  componentKey: z.string(),
+
+  /** Name of the package (from package.json) the component is imported from */
+  packageName: z.string(),
+
+  /** File path of the component, relative to the repository root */
+  componentPath: z.string(),
+
+  /** AI-generated markdown describing the component's API and usage */
+  markdown: z.string(),
+});
+
+export const DTOCodeComponentMarkdownResponse = z.object({
+  /** Components for which markdown was found */
+  components: DTOCodeComponentMarkdown.array(),
+});
+
+export type DTOCodeComponentProperty = z.infer<typeof DTOCodeComponentProperty>;
+export type DTOCodeComponentStorybookFile = z.infer<typeof DTOCodeComponentStorybookFile>;
+export type DTOCodeComponentDocFile = z.infer<typeof DTOCodeComponentDocFile>;
+export type DTOCodeComponent = z.infer<typeof DTOCodeComponent>;
+export type DTOCodeComponentListResponse = z.infer<typeof DTOCodeComponentListResponse>;
+export type DTOCodeComponentReference = z.infer<typeof DTOCodeComponentReference>;
+export type DTOCodeComponentMarkdownQuery = z.infer<typeof DTOCodeComponentMarkdownQuery>;
+export type DTOCodeComponentMarkdown = z.infer<typeof DTOCodeComponentMarkdown>;
+export type DTOCodeComponentMarkdownResponse = z.infer<typeof DTOCodeComponentMarkdownResponse>;

package/src/api/dto/design-systems/code-history.ts

@@ -0,0 +1,43 @@
+import z from "zod";
+
+export const DTOCodeHistoryRepositoryFilter = z.object({
+  repositoryName: z.string(),
+  usagePackageNames: z.array(z.string()).optional(),
+});
+
+export const DTOCodeHistoryQuery = z.object({
+  /** Filters components and usages by component package name (e.g. `@supernovaio/dm`) */
+  packageNames: z.array(z.string()).optional(),
+  /** Filters usages by component name (e.g. `Button`, `Icon`) */
+  componentNames: z.array(z.string()).optional(),
+  /**
+   * Filters usages by repository and optionally by usage package within that repository.
+   *
+   * - `{"repositoryName": "cloud"}` — all usages for this repository (no package filter)
+   * - `{"repositoryName": "cloud", "usagePackageNames": []}` — no usages for this repository
+   * - `{"repositoryName": "cloud", "usagePackageNames": ["@supernovaio/portal"]}` — only matching packages for this repository
+   */
+  repositoryFilters: z.array(DTOCodeHistoryRepositoryFilter).optional(),
+  /** Start of the time range filter (inclusive, ISO 8601 string) */
+  timeFrameFrom: z.string().optional(),
+  /** End of the time range filter (inclusive, ISO 8601 string) */
+  timeFrameTo: z.string().optional(),
+});
+
+export const DTOCodeHistorySnapshot = z.object({
+  scanId: z.string(),
+  scanTimestamp: z.string(),
+  totalComponents: z.number(),
+  componentsWithUsage: z.string(),
+  componentsWithStorybook: z.string(),
+  totalUsages: z.string(),
+});
+
+export const DTOCodeHistoryResponse = z.object({
+  snapshots: DTOCodeHistorySnapshot.array(),
+});
+
+export type DTOCodeHistoryRepositoryFilter = z.infer<typeof DTOCodeHistoryRepositoryFilter>;
+export type DTOCodeHistoryQuery = z.infer<typeof DTOCodeHistoryQuery>;
+export type DTOCodeHistorySnapshot = z.infer<typeof DTOCodeHistorySnapshot>;
+export type DTOCodeHistoryResponse = z.infer<typeof DTOCodeHistoryResponse>;

package/src/api/dto/design-systems/code-scan.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const DTOCodeScanUploadedBy = z.object({
+  userId: z.string(),
+  name: z.string(),
+  avatar: z.string().optional(),
+});
+
+export const DTOCodeScanListItem = z.object({
+  scanId: z.string(),
+  scanTimestamp: z.string(),
+  packageNames: z.array(z.string()),
+  repositoryName: z.string(),
+  uploadedBy: DTOCodeScanUploadedBy.optional(),
+  cliVersion: z.string().optional(),
+});
+
+export const DTOCodeScanListResponse = z.object({
+  scans: z.array(DTOCodeScanListItem),
+});
+
+export const DTOCodeScanDeleteResponse = z.object({
+  ok: z.literal(true),
+});
+
+export type DTOCodeScanUploadedBy = z.infer<typeof DTOCodeScanUploadedBy>;
+export type DTOCodeScanListItem = z.infer<typeof DTOCodeScanListItem>;
+export type DTOCodeScanListResponse = z.infer<typeof DTOCodeScanListResponse>;
+export type DTOCodeScanDeleteResponse = z.infer<typeof DTOCodeScanDeleteResponse>;

package/src/api/dto/design-systems/code-snapshots.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+export const DTOCodeSnapshotScannerType = z.enum(["Components", "Usage"]);
+
+export const DTOCodeSnapshotUploadInitResponse = z.object({
+  fileId: z.string(),
+  snapshotId: z.string(),
+  uploadUrl: z.string(),
+});
+
+export const DTOCodeSnapshotProcessingRunResponse = z.object({
+  processingRunId: z.string(),
+  snapshotIds: z.array(z.string()),
+});
+
+export const DTOCodeSnapshotFinalizeResponse = z.object({
+  ok: z.literal(true),
+  processingRunId: z.string().nullable(),
+  snapshotId: z.string(),
+});
+
+export const DTOCodeSnapshotProcessingRunStatus = z.enum(["Processing", "Processed", "Failed"]);
+
+export const DTOCodeSnapshotProcessingRunStatusItem = z.object({
+  createdAt: z.string(),
+  errorSummary: z.string().nullable(),
+  failedComponentsCount: z.number(),
+  finishedAt: z.string().nullable(),
+  processingRunId: z.string(),
+  snapshotIds: z.array(z.string()),
+  startedAt: z.string(),
+  status: DTOCodeSnapshotProcessingRunStatus,
+  updatedAt: z.string(),
+});
+
+export const DTOCodeSnapshotProcessingRunStatusResponse = z.object({
+  runs: z.array(DTOCodeSnapshotProcessingRunStatusItem),
+});
+
+export type DTOCodeSnapshotScannerType = z.infer<typeof DTOCodeSnapshotScannerType>;
+export type DTOCodeSnapshotUploadInitResponse = z.infer<typeof DTOCodeSnapshotUploadInitResponse>;
+export type DTOCodeSnapshotProcessingRunResponse = z.infer<typeof DTOCodeSnapshotProcessingRunResponse>;
+export type DTOCodeSnapshotFinalizeResponse = z.infer<typeof DTOCodeSnapshotFinalizeResponse>;
+export type DTOCodeSnapshotProcessingRunStatus = z.infer<typeof DTOCodeSnapshotProcessingRunStatus>;
+export type DTOCodeSnapshotProcessingRunStatusItem = z.infer<typeof DTOCodeSnapshotProcessingRunStatusItem>;
+export type DTOCodeSnapshotProcessingRunStatusResponse = z.infer<typeof DTOCodeSnapshotProcessingRunStatusResponse>;

package/src/api/dto/design-systems/component.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { DTOObjectMeta } from "../aux";
+
+//
+// Read
+//
+
+export const DTODesignSystemComponent = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+  brandId: z.string(),
+  meta: DTOObjectMeta,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const DTODesignSystemComponentResponse = z.object({
+  designSystemComponent: DTODesignSystemComponent,
+});
+
+export const DTODesignSystemComponentListResponse = z.object({
+  designSystemComponents: DTODesignSystemComponent.array(),
+});
+
+export type DTODesignSystemComponent = z.infer<typeof DTODesignSystemComponent>;
+export type DTODesignSystemComponentResponse = z.infer<typeof DTODesignSystemComponentResponse>;
+export type DTODesignSystemComponentListResponse = z.infer<typeof DTODesignSystemComponentListResponse>;
+
+//
+// Write
+//
+
+export const DTODesignSystemComponentCreateInput = z.object({
+  brandId: z.string(), // Persistent ID,
+  persistentId: z.string(),
+  meta: DTOObjectMeta,
+});
+
+export type DTODesignSystemComponentCreateInput = z.infer<typeof DTODesignSystemComponentCreateInput>;

package/src/api/dto/design-systems/contact.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { DTOUser } from "../users";
+
+export const DTODesignSystemContactsResponse = z.object({
+  contacts: z.object({
+    workspace: z.array(DTOUser),
+    designSystem: z.array(DTOUser),
+  }),
+});
+
+export type DTODesignSystemContactsResponse = z.infer<typeof DTODesignSystemContactsResponse>;

package/src/api/dto/design-systems/data-source.ts

@@ -0,0 +1,216 @@
+import {
+  DataSourceAutoImportMode,
+  DataSourceFigmaScope,
+  DataSourceFigmaState,
+  DataSourceRemoteType,
+  DataSourceStats,
+  DataSourceUploadImportMetadata,
+  DataSourceUploadRemoteSource,
+  SourceImportStorybookSummary,
+  SourceImportSummary,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTODataSourceFigmaScope = DataSourceFigmaScope;
+
+const DTODataSourceFigmaFileVersion = z.object({
+  id: z.string(),
+  created_at: z.coerce.date(),
+  label: z.string(),
+  description: z.string(),
+});
+
+export const DTODataSourceFigmaCloud = z.object({
+  fileId: z.string(),
+  state: DataSourceFigmaState,
+  autoImportMode: DataSourceAutoImportMode,
+  fileThumbnailUrl: z.string().optional(),
+  lastImportResult: SourceImportSummary.nullish(),
+  lastImportedAt: z.coerce.date().nullish(),
+  lastImportedVersion: DTODataSourceFigmaFileVersion.nullish(),
+  lastUpdatesCheckedAt: z.date().nullish(),
+  ownerId: z.string(),
+  ownerUserName: z.string().optional(),
+  preferredCredentialId: z.string().optional(),
+  stats: DataSourceStats,
+});
+
+export const DTODataSourceFigma = z.object({
+  id: z.string(),
+  type: z.literal(DataSourceRemoteType.Enum.Figma),
+  fileName: z.string(),
+  scope: DTODataSourceFigmaScope,
+  brandId: z.string(),
+  themeId: z.string().nullish(),
+  cloud: DTODataSourceFigmaCloud.nullish(),
+  sortOrder: z.number().optional(),
+});
+
+// TS is not yet implemented in new BE
+export const DTODataSourceTokenStudio = z.object({
+  id: z.string(),
+  type: z.literal(DataSourceRemoteType.Enum.TokenStudio),
+  fileName: z.string(),
+  brandId: z.string(),
+  themeId: z.string().nullish(),
+  sortOrder: z.number().optional(),
+  tokenStudio: z.object({
+    settings: z.object({
+      dryRun: z.boolean(),
+      verbose: z.boolean(),
+      preciseCopy: z.boolean(),
+    }),
+    connectionName: z.string(),
+    lastImportedAt: z.coerce.date(),
+    lastImportedResults: z.array(
+      z.object({
+        mapping: z.object({
+          tokenSets: z.array(z.string()),
+          supernovaBrand: z.string(),
+          supernovaTheme: z.string().optional(),
+        }),
+        isFailed: z.boolean(),
+        tokensCreated: z.number(),
+        tokensDeleted: z.number(),
+        tokensUpdated: z.number(),
+      })
+    ),
+  }),
+});
+
+export const DTODataSourceFigmaVariablesPlugin = z.object({
+  id: z.string(),
+  type: z.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
+  fileName: z.string(),
+  brandId: z.string(),
+  sortOrder: z.number().optional(),
+  upload: z.object({
+    remoteId: z.string(),
+    remoteSourceType: DataSourceUploadRemoteSource,
+    lastImportedAt: z.coerce.date().optional(),
+    lastImportMetadata: DataSourceUploadImportMetadata.optional(),
+    isTokenTypeSplitEnabled: z.boolean(),
+  }),
+  figmaVariablesPlugin: z.object({
+    fileId: z.string(),
+    lastImportedAt: z.coerce.date().optional(),
+    lastImportMetadata: DataSourceUploadImportMetadata.optional(),
+    isTokenTypeSplitEnabled: z.boolean(),
+    isCollectionsMigrationCompleted: z.boolean().default(false),
+    isCollectionKeysMigrationCompleted: z.boolean().default(false),
+  }),
+});
+
+export const DTODataSourceStorybook = z.object({
+  id: z.string(),
+  type: z.literal(DataSourceRemoteType.Enum.Storybook),
+  fileName: z.string(),
+  brandId: z.string(),
+  sortOrder: z.number().optional(),
+  storybook: z.object({
+    indexUrl: z.string(),
+    userUrl: z.string(),
+    lastImportedAt: z.coerce.date().optional(),
+    lastImportedResult: SourceImportStorybookSummary.optional(),
+    lastImportedSuccessfully: z.coerce.date().optional(),
+    isFailed: z.boolean(),
+    storiesCount: z.number(),
+    docsCount: z.number(),
+    description: z.string().optional(),
+    isUsingVpn: z.boolean().optional(),
+  }),
+});
+
+export const DTODataSourcesStorybookResponse = z.object({
+  isFailed: z.boolean(),
+  storiesCount: z.number(),
+  docsCount: z.number(),
+  created: z.array(z.string()).optional(),
+  updated: z.array(z.string()).optional(),
+  deleted: z.array(z.string()).optional(),
+});
+
+export const DTODataSource = z.discriminatedUnion("type", [
+  DTODataSourceFigma,
+  DTODataSourceFigmaVariablesPlugin,
+  DTODataSourceTokenStudio,
+  DTODataSourceStorybook,
+]);
+
+export const DTODataSourcesListResponse = z.object({
+  sources: z.array(DTODataSource),
+});
+
+export const DTODataSourceResponse = z.object({
+  source: DTODataSource,
+});
+
+export type DTODataSourceFigma = z.infer<typeof DTODataSourceFigma>;
+export type DTODataSourceTokenStudio = z.infer<typeof DTODataSourceTokenStudio>;
+export type DTODataSourceFigmaVariablesPlugin = z.infer<typeof DTODataSourceFigmaVariablesPlugin>;
+export type DTODataSourceStorybook = z.infer<typeof DTODataSourceStorybook>;
+export type DTODataSource = z.infer<typeof DTODataSource>;
+export type DTODataSourceResponse = z.infer<typeof DTODataSourceResponse>;
+export type DTODataSourcesListResponse = z.infer<typeof DTODataSourcesListResponse>;
+export type DTODataSourcesStorybookResponse = z.infer<typeof DTODataSourcesStorybookResponse>;
+
+//
+// Write
+//
+
+export const DTODataSourceFigmaCreatePayload = z.object({
+  brandPersistentId: z.string(),
+  figmaFileUrl: z.string(),
+  scope: DTODataSourceFigmaScope,
+  autoImportMode: DataSourceAutoImportMode,
+});
+
+export const DTODataSourceFigmaImportPayload = z.object({
+  sourceIds: z.array(z.string()),
+});
+
+export const DTODataSourceStorybookCreatePayload = z.object({
+  brandPersistentId: z.string(),
+  fileName: z.string().optional(),
+  userUrl: z.string(),
+  indexUrl: z.string(),
+  payload: z.unknown(),
+  type: z.literal(DataSourceRemoteType.Enum.Storybook),
+  description: z.string().optional(),
+  isUsingVpn: z.boolean().optional(),
+});
+
+export const DTOStorybookImportPayload = z.object({
+  sourceId: z.string(),
+  payload: z.unknown(),
+});
+
+export const DTOStorybookSourceUpdatePayload = z.object({
+  description: z.string().nullish().optional(),
+  isUsingVpn: z.boolean().optional(),
+  fileName: z.string().optional(),
+});
+
+export const DTOFigmaSourceUpdatePayload = z.object({
+  themeId: z.string().nullish(),
+  scope: DataSourceFigmaScope.optional(),
+  autoImportMode: DataSourceAutoImportMode.optional(),
+});
+
+export const DTOFVPMigrationsCollectionKeysPayload = z.object({
+  pluginFileId: z.string(),
+  collectionIdToKeyMap: z.record(z.string()),
+});
+
+export type DTODataSourceFigmaScope = z.infer<typeof DTODataSourceFigmaScope>;
+export type DTODataSourceFigmaCreatePayload = z.infer<typeof DTODataSourceFigmaCreatePayload>;
+export type DTODataSourceStorybookCreatePayload = z.infer<typeof DTODataSourceStorybookCreatePayload>;
+export type DTODataSourceFigmaImportPayload = z.infer<typeof DTODataSourceFigmaImportPayload>;
+export type DTOStorybookImportPayload = z.infer<typeof DTOStorybookImportPayload>;
+export type DTOStorybookSourceUpdatePayload = z.infer<typeof DTOStorybookSourceUpdatePayload>;
+export type DTOFigmaSourceUpdatePayload = z.infer<typeof DTOFigmaSourceUpdatePayload>;
+export type DTOFVPMigrationsCollectionKeysPayload = z.infer<typeof DTOFVPMigrationsCollectionKeysPayload>;

package/src/api/dto/design-systems/design-system.ts

@@ -0,0 +1,75 @@
+import { DesignSystem, DesignSystemAccessMode, ObjectMeta, WorkspaceRoleSchema } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOFileReference } from "../files";
+import { DTODesignSystemMembersUpdatePayload } from "./members";
+import { DTODesignSystemRole } from "./role";
+
+//
+// Read
+//
+
+export const DTODesignSystem = DesignSystem.omit({
+  name: true,
+  description: true,
+  docExporterId: true,
+  sharedDraftId: true,
+  iconFilePath: true,
+}).extend({
+  meta: ObjectMeta,
+  docExporterId: z.string(),
+  sources: z.array(z.any()),
+  isPublic: z.literal(true),
+  sharedDraftId: z.string(),
+
+  icon: DTOFileReference.optional(),
+
+  /**
+   * Whether or not user who is requesting the design system
+   * has access to the design system's contents.
+   */
+  isAvailableToUser: z.boolean(),
+
+  /**
+   * @deprecated
+   */
+  role: WorkspaceRoleSchema.optional(),
+
+  /**
+   * User's role within the design system that can come either from
+   * the design system or workspace.
+   */
+  effectiveRole: DTODesignSystemRole.optional(),
+});
+
+export const DTODesignSystemResponse = z.object({
+  designSystem: DTODesignSystem,
+});
+
+export const DTODesignSystemsListResponse = z.object({
+  designSystems: DTODesignSystem.array(),
+});
+
+export type DTODesignSystem = z.infer<typeof DTODesignSystem>;
+export type DTODesignSystemResponse = z.infer<typeof DTODesignSystemResponse>;
+export type DTODesignSystemsListResponse = z.infer<typeof DTODesignSystemsListResponse>;
+
+//
+// Write
+//
+
+export const DTODesignSystemCreateInput = z.object({
+  workspaceId: z.string(),
+  meta: ObjectMeta.optional(),
+  name: z.string().min(2).max(64).optional(),
+  description: z.string().max(1024).optional(),
+  accessMode: DesignSystemAccessMode.optional(),
+  iconFileId: z.string().optional(),
+
+  invites: DTODesignSystemMembersUpdatePayload.pick({
+    usersToInvite: true,
+    invitesToInvite: true,
+    emailsToInvite: true,
+  }).optional(),
+});
+
+export type DTODesignSystemCreateInput = z.infer<typeof DTODesignSystemCreateInput>;

package/src/api/dto/design-systems/documentation-search.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+
+export const DTODocumentationSearchIndexResponse = z.object({
+  indexedPages: z.number(),
+  totalPages: z.number(),
+  errors: z.number(),
+});
+
+export const DTODocumentationSearchQuery = 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),
+});
+
+export const DTODocumentationSearchResult = z.object({
+  pageId: z.string(),
+  title: z.string(),
+  excerpt: z.string(),
+  vectorScore: z.number().nullable(),
+  fullTextScore: z.number().nullable(),
+  reciprocalRankFusionScore: z.number(),
+});
+
+export const DTODocumentationSearchResponse = z.object({
+  results: z.array(DTODocumentationSearchResult),
+});
+
+export type DTODocumentationSearchIndexResponse = z.infer<typeof DTODocumentationSearchIndexResponse>;
+export type DTODocumentationSearchQuery = z.infer<typeof DTODocumentationSearchQuery>;
+export type DTODocumentationSearchResult = z.infer<typeof DTODocumentationSearchResult>;
+export type DTODocumentationSearchResponse = z.infer<typeof DTODocumentationSearchResponse>;

package/src/api/dto/design-systems/elements-diff.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const DTODiffCountBase = z.object({
+  created: z.number(),
+  updated: z.number(),
+  deleted: z.number(),
+});
+
+export const DTODesignElementsDataDiffResponse = z.object({
+  tokens: DTODiffCountBase,
+  assets: DTODiffCountBase,
+});
+
+export type DTODesignElementsDataDiffResponse = z.infer<typeof DTODesignElementsDataDiffResponse>;