@supernova-studio/client 1.96.5 → 1.96.7

package/src/api/conversion/documentation/documentation-page-to-dto-utils.ts

@@ -0,0 +1,134 @@
+import {
+  DocumentationGroupV1,
+  DocumentationItemConfigurationV1,
+  DocumentationItemConfigurationV2,
+  DocumentationPageV1,
+  mapByUnique,
+} from "@supernova-studio/model";
+import { LocalDocsPage, LocalDocsPageGroup } from "../../../sync/types";
+import { VersionRoomDocsPage, VersionRoomDocsPageGroup } from "../../../yjs/version-room/types";
+
+type GroupLike = {
+  persistentId: string;
+  parentPersistentId?: string;
+};
+
+type DocsPage = LocalDocsPage | VersionRoomDocsPage;
+type DocsPageGroup = LocalDocsPageGroup | VersionRoomDocsPageGroup;
+
+// The fact that DTO conversion is located here instead of main backend code is due to the fact
+// that we store page and group data in YJS documents in the same way as they are stored in the database.
+// Therefore, we need to expose this conversion to the client so that it can consume data from YJS documents.
+//
+// Please do not put more DTO conversion here unless you know what you're doing.
+
+export function buildDocPagePublishPaths(
+  groups: (DocsPageGroup | DocumentationGroupV1)[],
+  pages: (DocsPage | DocumentationPageV1)[],
+  routingVersion: string
+): Map<string, string> {
+  const groupPersistentIdToGroupMap = mapByUnique(groups, group => group.persistentId);
+  const result = new Map<string, string>();
+
+  for (const page of pages) {
+    const parentChain = calculateElementParentChain(page.parentPersistentId, groupPersistentIdToGroupMap);
+
+    let pathV1 = `${page.userSlug || page.slug}.html`;
+    let pathV2 = `${page.slug}-${page.shortPersistentId}`;
+
+    for (const parent of parentChain) {
+      if (!parent.parentPersistentId) continue;
+
+      pathV1 = `${parent.userSlug || parent.slug || "root"}/${pathV1}`;
+      pathV2 = `${parent.slug || "root"}/${pathV2}`;
+    }
+
+    pathV1 = `/${pathV1}`;
+    pathV2 = `/${pathV2}`;
+
+    if (routingVersion === "2") {
+      result.set(page.persistentId, pathV2);
+    } else {
+      result.set(page.persistentId, pathV1);
+    }
+  }
+
+  return result;
+}
+
+export function calculateElementParentChain<T extends GroupLike>(
+  elementParentPersistentId: string,
+  groupPersistentIdToGroupMap: Map<string, T>
+): T[] {
+  const result: T[] = [];
+
+  let parentId: string | undefined = elementParentPersistentId;
+  while (parentId) {
+    const parent = groupPersistentIdToGroupMap.get(parentId);
+    if (parent) result.push(parent);
+
+    parentId = parent?.parentPersistentId;
+  }
+
+  return result;
+}
+
+export function applyPrivacyConfigurationToNestedItems<
+  PageType extends DocumentationPageV1 | DocsPage,
+  GroupType extends DocumentationGroupV1 | DocsPageGroup,
+  ItemConfigurationType extends DocumentationItemConfigurationV1 | DocumentationItemConfigurationV2
+>(
+  pages: PageType[],
+  groups: GroupType[],
+  getDefaultItemConfiguration: () => ItemConfigurationType
+): { pages: PageType[]; groups: GroupType[] } {
+  // copy groups to mutate them later
+  const fixedGroups = groups.map(group => ({
+    ...group,
+    data: {
+      ...group.data,
+      configuration: group.data?.configuration ?? getDefaultItemConfiguration(),
+    },
+  }));
+  const groupPersistentIdToGroupMap = mapByUnique(fixedGroups, group => group.persistentId);
+
+  for (const groupToFix of fixedGroups) {
+    let isHidden = groupToFix.data.configuration.isHidden;
+    let isPrivate = groupToFix.data.configuration.isPrivate;
+
+    let nextParentId: string | undefined = groupToFix.parentPersistentId;
+    while ((!isHidden || !isPrivate) && nextParentId) {
+      const parent = groupPersistentIdToGroupMap.get(nextParentId);
+      if (!parent) break;
+
+      isHidden = isHidden || parent.data?.configuration?.isHidden || false;
+      isPrivate = isPrivate || parent.data?.configuration?.isPrivate || false;
+
+      nextParentId = parent.parentPersistentId;
+    }
+
+    groupToFix.data.configuration.isHidden = isHidden;
+    groupToFix.data.configuration.isPrivate = isPrivate;
+  }
+
+  const fixedPages: PageType[] = [];
+  // set isHidden and isPrivate configuration fields based on page and parents value
+  for (const page of pages) {
+    const configuration = page.data?.configuration ?? getDefaultItemConfiguration();
+    const parent = groupPersistentIdToGroupMap.get(page.parentPersistentId);
+
+    fixedPages.push({
+      ...page,
+      data: {
+        ...page.data,
+        configuration: {
+          ...configuration,
+          isHidden: configuration.isHidden || parent?.data?.configuration?.isHidden || false,
+          isPrivate: configuration.isPrivate || parent?.data?.configuration?.isPrivate || false,
+        },
+      },
+    });
+  }
+
+  return { pages: fixedPages, groups: fixedGroups };
+}

package/src/api/conversion/documentation/documentation-page-v1-to-dto.ts

@@ -0,0 +1,69 @@
+import {
+  DocumentationGroupV1,
+  DocumentationItemConfigurationV1,
+  DocumentationPageV1,
+  SupernovaException,
+} from "@supernova-studio/model";
+import { DocumentationPageV1DTO } from "../../dto";
+import {
+  documentationItemConfigurationToDTOV1,
+  getDtoDefaultItemConfigurationV1,
+} from "./documentation-item-configuration-v1-to-dto";
+import { buildDocPagePublishPaths, applyPrivacyConfigurationToNestedItems } from "./documentation-page-to-dto-utils";
+
+// The fact that DTO conversion is located here instead of main backend code is due to the fact
+// that we store page and group data in YJS documents in the same way as they are stored in the database.
+// Therefore, we need to expose this conversion to the client so that it can consume data from YJS documents.
+//
+// Please do not put more DTO conversion here unless you know what you're doing.
+
+export function documentationPagesToDTOV1(
+  pages: DocumentationPageV1[],
+  groups: DocumentationGroupV1[],
+  routingVersion: string
+): DocumentationPageV1DTO[] {
+  const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
+
+  return pages.map(page => documentationPageToDTOV1(page, pathsMap));
+}
+
+export function documentationPagesFixedConfigurationToDTOV1(
+  pages: DocumentationPageV1[],
+  groups: DocumentationGroupV1[],
+  routingVersion: string
+): DocumentationPageV1DTO[] {
+  const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
+
+  const { pages: fixedPages } = applyPrivacyConfigurationToNestedItems<
+    DocumentationPageV1,
+    DocumentationGroupV1,
+    DocumentationItemConfigurationV1
+  >(pages, groups, getDtoDefaultItemConfigurationV1);
+
+  return fixedPages.map((page: DocumentationPageV1) => documentationPageToDTOV1(page, pathsMap));
+}
+
+function documentationPageToDTOV1(page: DocumentationPageV1, pagePathMap: Map<string, string>): DocumentationPageV1DTO {
+  let path = pagePathMap.get(page.persistentId);
+  if (!path) throw SupernovaException.conflict(`Path for page ${page.id} was not calculated`);
+
+  if (path.startsWith("/")) path = path.substring(1);
+
+  const configuration = documentationItemConfigurationToDTOV1(page.data.configuration);
+
+  return {
+    id: page.id,
+    designSystemVersionId: page.designSystemVersionId,
+    persistentId: page.persistentId,
+    shortPersistentId: page.shortPersistentId,
+    // backward compatibility with custom doc exporters, anyway these pages will not be shown, so we can adjust title
+    title: configuration.isHidden && !page.meta.name.startsWith("_") ? "_" + page.meta.name : page.meta.name,
+    blocks: page.data.blocks,
+    slug: page.slug,
+    userSlug: page.userSlug,
+    configuration,
+    createdAt: page.createdAt,
+    updatedAt: page.updatedAt,
+    path: path,
+  };
+}

package/src/api/conversion/documentation/documentation-page-v2-to-dto.ts

@@ -0,0 +1,84 @@
+import { DocumentationItemConfigurationV2 } from "@supernova-studio/model";
+import { LocalDocsPage, LocalDocsPageGroup } from "../../../sync/types";
+import { VersionRoomDocsPage, VersionRoomDocsPageGroup } from "../../../yjs/version-room/types";
+import { DTODocumentationPageV2 } from "../../dto";
+import {
+  documentationItemConfigurationToDTOV2,
+  getDtoDefaultItemConfigurationV2,
+} from "./documentation-item-configuration-v2-to-dto";
+import { applyPrivacyConfigurationToNestedItems, buildDocPagePublishPaths } from "./documentation-page-to-dto-utils";
+
+type DocsPage = LocalDocsPage | VersionRoomDocsPage;
+type DocsPageGroup = LocalDocsPageGroup | VersionRoomDocsPageGroup;
+
+// The fact that DTO conversion is located here instead of main backend code is due to the fact
+// that we store page and group data in YJS documents in the same way as they are stored in the database.
+// Therefore, we need to expose this conversion to the client so that it can consume data from YJS documents.
+//
+// Please do not put more DTO conversion here unless you know what you're doing.
+
+export function documentationPageToDTOV2(
+  page: DocsPage,
+  groups: DocsPageGroup[],
+  routingVersion: string,
+  pageLiveblocksRoomIdMap: Map<string, string>
+): DTODocumentationPageV2 {
+  const pathsMap = buildDocPagePublishPaths(groups, [page], routingVersion);
+  return _documentationPageToDTOV2(page, pathsMap, pageLiveblocksRoomIdMap);
+}
+
+export function documentationPagesToDTOV2(
+  pages: DocsPage[],
+  groups: DocsPageGroup[],
+  routingVersion: string,
+  pageLiveblocksRoomIdMap: Map<string, string>
+): DTODocumentationPageV2[] {
+  const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
+  return pages.map(page => _documentationPageToDTOV2(page, pathsMap, pageLiveblocksRoomIdMap));
+}
+
+export function documentationPagesFixedConfigurationToDTOV2(
+  pages: DocsPage[],
+  groups: DocsPageGroup[],
+  routingVersion: string,
+  pageLiveblocksRoomIdMap: Map<string, string>
+): DTODocumentationPageV2[] {
+  const pathsMap = buildDocPagePublishPaths(groups, pages, routingVersion);
+
+  const { pages: fixedPages } = applyPrivacyConfigurationToNestedItems<
+    DocsPage,
+    DocsPageGroup,
+    DocumentationItemConfigurationV2
+  >(pages, groups, getDtoDefaultItemConfigurationV2);
+
+  return fixedPages.map(page => _documentationPageToDTOV2(page, pathsMap, pageLiveblocksRoomIdMap));
+}
+
+function _documentationPageToDTOV2(
+  page: DocsPage,
+  pagePathMap: Map<string, string>,
+  pageLiveblocksRoomIdMap: Map<string, string>
+): DTODocumentationPageV2 {
+  let path = pagePathMap.get(page.persistentId);
+  if (!path) throw new Error(`Path for page ${page.persistentId} was not calculated`);
+
+  if (path.startsWith("/")) path = path.substring(1);
+
+  const liveblocksRoomId = pageLiveblocksRoomIdMap.get(page.persistentId);
+
+  return {
+    id: "to_be_removed",
+    designSystemVersionId: page.designSystemVersionId,
+    persistentId: page.persistentId,
+    shortPersistentId: page.shortPersistentId,
+    title: page.meta.name,
+    slug: page.slug,
+    userSlug: page.userSlug,
+    configuration: documentationItemConfigurationToDTOV2(page.data.configuration),
+    createdAt: page.createdAt,
+    updatedAt: page.updatedAt,
+    path: path,
+    type: "Page",
+    ...(liveblocksRoomId && { liveblocksRoomId }),
+  };
+}

package/src/api/conversion/documentation/documentation-settings-to-dto.ts

@@ -0,0 +1,14 @@
+import { DocumentationConfiguration } from "@supernova-studio/model";
+import { DTODocumentationConfiguration } from "../../dto";
+
+export function documentationConfigurationToDto(
+  configuration: DocumentationConfiguration
+): DTODocumentationConfiguration {
+  return {
+    isPublic: configuration.isPublic,
+    renderCodePackageJson: configuration.renderCodePackageJson,
+    selectedBrandId: configuration.selectedBrandPersistentId,
+    storybookEmbedErrorMessage: configuration.storybookEmbedErrorMessage,
+    tabbed: configuration.isTabbedLayoutEnabled,
+  };
+}

package/src/api/conversion/documentation/index.ts

@@ -0,0 +1,8 @@
+export * from "./documentation-group-v1-to-dto";
+export * from "./documentation-group-v2-to-dto";
+export * from "./documentation-item-configuration-v1-to-dto";
+export * from "./documentation-item-configuration-v2-to-dto";
+export * from "./documentation-page-to-dto-utils";
+export * from "./documentation-page-v1-to-dto";
+export * from "./documentation-page-v2-to-dto";
+export * from "./documentation-settings-to-dto";

package/src/api/conversion/export/index.ts

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

package/src/api/conversion/export/pipeline.ts

@@ -0,0 +1,27 @@
+import { Pipeline } from "@supernova-studio/model";
+import { DTOPipeline } from "../../dto/export/pipeline";
+
+export function pipelineToDto(pipeline: Pipeline): DTOPipeline {
+  return {
+    id: pipeline.id,
+    name: pipeline.name,
+    eventType: pipeline.eventType,
+    isEnabled: pipeline.isEnabled,
+    workspaceId: pipeline.workspaceId,
+    designSystemId: pipeline.designSystemId,
+    exporterId: pipeline.exporterId,
+    brandPersistentId: pipeline.brandPersistentId,
+    themePersistentId: pipeline.themePersistentId,
+    themePersistentIds: pipeline.themePersistentIds,
+    destinationAzure: pipeline.destinationAzure,
+    destinationBitbucket: pipeline.destinationBitbucket,
+    destinationSnDocs: pipeline.destinationSnDocs,
+    destinationGithub: pipeline.destinationGithub,
+    destinationGitlab: pipeline.destinationGitlab,
+    destinationS3: pipeline.destinationS3,
+    exporterPropertyValues: pipeline.exporterPropertyValues,
+    webhookUrl: pipeline.webhookUrl,
+    latestJobs: [],
+    isExporterDeprecated: pipeline.isExporterDeprecated,
+  };
+}

package/src/api/conversion/index.ts

@@ -0,0 +1,4 @@
+export * from "./analytics";
+export * from "./documentation";
+export * from "./export";
+export * from "./integrations";

package/src/api/conversion/integrations/git.ts

@@ -0,0 +1,37 @@
+import { GitBranch, GitOrganization, GitProject, GitRepository } from "@supernova-studio/model";
+import { DTOGitBranch, DTOGitOrganization, DTOGitProject, DTOGitRepository } from "../../dto";
+
+export function gitOrganizationToDto(org: GitOrganization): DTOGitOrganization {
+  return {
+    id: org.id,
+    name: org.name,
+    url: org.url,
+    slug: org.slug,
+  };
+}
+
+export function gitProjectToDto(project: GitProject): DTOGitProject {
+  return {
+    id: project.id,
+    name: project.name,
+    url: project.url,
+    slug: project.slug,
+  };
+}
+
+export function gitRepositoryToDto(repo: GitRepository): DTOGitRepository {
+  return {
+    id: repo.id,
+    name: repo.name,
+    url: repo.url,
+    slug: repo.slug,
+    defaultBranch: repo.defaultBranch,
+  };
+}
+
+export function gitBranchToDto(branch: GitBranch): DTOGitBranch {
+  return {
+    name: branch.name,
+    lastCommitId: branch.lastCommitId,
+  };
+}

package/src/api/conversion/integrations/index.ts

@@ -0,0 +1,2 @@
+export * from "./git";
+export * from "./integration";

package/src/api/conversion/integrations/integration.ts

@@ -0,0 +1,37 @@
+import { ExtendedIntegration, IntegrationCredentials } from "@supernova-studio/model";
+import { DTOIntegration, DTOIntegrationCredentials } from "../../dto";
+
+export function integrationToDto(integration: ExtendedIntegration): DTOIntegration {
+  return {
+    id: integration.id,
+    workspaceId: integration.workspaceId,
+    type: integration.type,
+    createdAt: integration.createdAt,
+    integrationCredentials: integration.integrationCredentials?.map(integrationCredentialToDto),
+    integrationDesignSystems: integration.integrationDesignSystems ?? undefined,
+  };
+}
+
+export function integrationCredentialToDto(credential: IntegrationCredentials): DTOIntegrationCredentials {
+  return {
+    id: credential.id,
+
+    createdAt: credential.createdAt,
+    refreshedAt: credential.refreshedAt,
+    expiresAt: credential.expiresAt,
+
+    integrationId: credential.integrationId,
+    type: credential.type,
+
+    userId: credential.userId,
+    user: credential.user,
+
+    customUrl: credential.customUrl,
+
+    profile: credential.profile,
+    tokenName: credential.tokenName,
+    username: credential.username,
+    appInstallationId: credential.appInstallationId,
+    state: credential.state,
+  };
+}

package/src/api/dto/access-tokens/access-token.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTOAccessToken = z.object({
+  id: z.string(),
+  createdAt: z.coerce.date(),
+  name: z.string(),
+  scope: z.string().optional(),
+});
+
+export const DTOAccessTokenFull = DTOAccessToken.extend({
+  token: z.string(),
+});
+
+export const DTOAccessTokenListResponse = z.object({
+  tokens: DTOAccessToken.array(),
+});
+
+export const DTOAccessTokenResponse = z.object({
+  token: DTOAccessToken,
+});
+
+export const DTOAccessTokenFullResponse = z.object({
+  token: DTOAccessTokenFull,
+});
+
+export type DTOAccessToken = z.infer<typeof DTOAccessToken>;
+export type DTOAccessTokenFull = z.infer<typeof DTOAccessTokenFull>;
+export type DTOAccessTokenListResponse = z.infer<typeof DTOAccessTokenListResponse>;
+export type DTOAccessTokenResponse = z.infer<typeof DTOAccessTokenResponse>;
+export type DTOAccessTokenFullResponse = z.infer<typeof DTOAccessTokenFullResponse>;
+
+//
+// Write
+//
+
+export const DTOAccessTokenCreatePayload = z.object({
+  name: z.string(),
+  scope: z.string().optional(),
+});
+
+export type DTOAccessTokenCreatePayload = z.infer<typeof DTOAccessTokenCreatePayload>;

package/src/api/dto/access-tokens/index.ts

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

package/src/api/dto/aux/color.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const DTOColorTokenInlineData = z.object({
+  value: z.string().regex(/^#[a-f0-9]{6,8}$/),
+});
+
+export type DTOColorTokenInlineData = z.infer<typeof DTOColorTokenInlineData>;

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

@@ -0,0 +1,4 @@
+export * from "./color";
+export * from "./meta";
+export * from "./object-metadata";
+export * from "./pagination";

package/src/api/dto/aux/meta.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const DTOObjectMeta = z.object({
+  name: z.string().max(512),
+  description: z.string().max(2048).optional(),
+});
+
+export type DTOObjectMeta = z.infer<typeof DTOObjectMeta>;

package/src/api/dto/aux/object-metadata.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+
+const MAX_OBJECT_METADATA_BYTES = 1024 * 1024;
+
+function getJsonByteLength(value: JsonValue): number {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+
+export const DTOObjectMetadata: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(DTOObjectMetadata),
+    z.record(DTOObjectMetadata),
+  ])
+).superRefine((metadata, ctx) => {
+  if (getJsonByteLength(metadata) > MAX_OBJECT_METADATA_BYTES) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Object metadata must be 1MB or smaller.",
+    });
+  }
+}).describe("Optional JSON metadata for extra structured details. Must be 1MB or smaller when serialized.");
+
+export type DTOObjectMetadata = z.infer<typeof DTOObjectMetadata>;

package/src/api/dto/aux/pagination.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const DTOPagination = z.object({
+  limit: z.string().optional(),
+  offset: z.string().optional(),
+});
+
+export type DTOPagination = z.infer<typeof DTOPagination>;

package/src/api/dto/bff/app-bootstrap-data.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { DTOBrand, DTODesignSystem, DTODesignSystemVersion } from "../design-systems";
+import { DTOUserWorkspaceMembership } from "../workspaces";
+
+export const DTOAppBootstrapDataQuery = z.object({
+  preferredWorkspaceId: z.string().optional(),
+  preferredDesignSystemId: z.string().optional(),
+  preferredVersionId: z.string().optional(),
+  preferredBrandId: z.string().optional(),
+});
+
+export const DTOAppBootstrapDataResponse = z.object({
+  workspaceMembership: DTOUserWorkspaceMembership.optional(),
+  designSystem: DTODesignSystem.optional(),
+  version: DTODesignSystemVersion.optional(),
+  brand: DTOBrand.optional(),
+});
+
+export type DTOAppBootstrapDataQuery = z.infer<typeof DTOAppBootstrapDataQuery>;
+export type DTOAppBootstrapDataResponse = z.infer<typeof DTOAppBootstrapDataResponse>;

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

@@ -0,0 +1 @@
+export * from "./app-bootstrap-data";

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

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

package/src/api/dto/collections/token-collection.ts

@@ -0,0 +1,32 @@
+import { CollectionOrigin, ColorTokenInlineData, ObjectMeta } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOCollectionOrigin = CollectionOrigin.extend({
+  /** @deprecated Use `sourceIds` instead. This field will be removed in the future. */
+  sourceId: z.string(),
+});
+
+export const DTOTokenCollection = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+
+  meta: ObjectMeta,
+  backgroundColor: ColorTokenInlineData.optional(),
+  elementPropertyOptionId: z.string(),
+
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+
+  parentPersistentId: z.string().optional(),
+
+  origin: DTOCollectionOrigin.optional(),
+});
+
+export type DTOCollectionOrigin = z.infer<typeof DTOCollectionOrigin>;
+export const DTOTokenCollectionsListReponse = z.object({
+  collections: DTOTokenCollection.array(),
+});
+
+export type DTOTokenCollection = z.infer<typeof DTOTokenCollection>;
+export type DTOTokenCollectionsListReponse = z.infer<typeof DTOTokenCollectionsListReponse>;

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

@@ -0,0 +1,44 @@
+import { ObjectMeta } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOObjectMeta } from "../aux";
+
+//
+// Read
+//
+
+export const DTOBrand = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  persistentId: z.string(),
+  meta: ObjectMeta,
+});
+
+export const DTOBrandGetResponse = z.object({ brand: DTOBrand });
+
+export const DTOBrandCreateResponse = z.object({
+  brand: DTOBrand,
+});
+
+export const DTOBrandsListResponse = z.object({ brands: z.array(DTOBrand) });
+
+export type DTOBrand = z.infer<typeof DTOBrand>;
+export type DTOBrandGetResponse = z.infer<typeof DTOBrandGetResponse>;
+export type DTOBrandCreateResponse = z.infer<typeof DTOBrandCreateResponse>;
+export type DTOBrandsListResponse = z.infer<typeof DTOBrandsListResponse>;
+
+//
+// Write
+//
+
+export const DTOBrandCreatePayload = z.object({
+  persistentId: z.string().uuid(),
+  meta: DTOObjectMeta,
+});
+
+export const DTOBrandUpdatePayload = z.object({
+  meta: DTOObjectMeta.optional(),
+  persistentId: z.string(),
+});
+
+export type DTOBrandCreatePayload = z.infer<typeof DTOBrandCreatePayload>;
+export type DTOBrandUpdatePayload = z.infer<typeof DTOBrandUpdatePayload>;