@supernova-studio/model 0.0.4

package/src/dsm/import/figma-frames.ts

@@ -0,0 +1,74 @@
+import { ZodType, ZodTypeDef, z } from "zod";
+import { ImportModelBase, ImportModelInputBase } from "./base";
+import { FigmaFileStructureOrigin } from "../elements";
+import { FigmaFileStructureNodeBase, FigmaFileStructureStatistics } from "../elements";
+import { FigmaPngRenderImportModel } from "./image";
+
+//
+// Nodes Import Model
+//
+
+const FigmaFileStructureNodeImportModelBase = FigmaFileStructureNodeBase.extend({
+  image: FigmaPngRenderImportModel,
+});
+
+export const FigmaFileStructureNodeImportModel: z.ZodType<
+  FigmaFileStructureNodeImportModel,
+  ZodTypeDef,
+  FigmaFileStructureNodeImportModelBaseInput
+> = FigmaFileStructureNodeImportModelBase.extend({
+  children: z.lazy(() => FigmaFileStructureNodeImportModel.array()),
+});
+
+type FigmaFileStructureNodeImportModelBaseInput = z.input<typeof FigmaFileStructureNodeImportModelBase> & {
+  children: FigmaFileStructureNodeImportModelBaseInput[];
+};
+
+export type FigmaFileStructureNodeImportModel = z.infer<typeof FigmaFileStructureNodeImportModelBase> & {
+  children: FigmaFileStructureNodeImportModel[];
+};
+
+//
+// Structure Import Model
+//
+
+const FigmaFileStructureImportModelPart = z.object({
+  data: z.object({
+    rootNode: FigmaFileStructureNodeImportModel,
+    assetsInFile: FigmaFileStructureStatistics,
+  }),
+});
+
+export const FigmaFileStructureImportModel = ImportModelBase.extend(FigmaFileStructureImportModelPart.shape).extend({
+  origin: FigmaFileStructureOrigin,
+});
+
+export type FigmaFileStructureImportModel = z.infer<typeof FigmaFileStructureImportModel>;
+
+//
+// Import model input
+//
+
+export const FigmaFileStructureImportModelInput = ImportModelInputBase.extend(
+  FigmaFileStructureImportModelPart.shape
+).extend({
+  fileVersionId: z.string(),
+});
+
+export type FigmaFileStructureImportModelInput = z.infer<typeof FigmaFileStructureImportModelInput>;
+
+export function figmaFileStructureImportModelToMap(
+  root: FigmaFileStructureNodeImportModel
+): Map<string, FigmaFileStructureNodeImportModel> {
+  const map = new Map<string, FigmaFileStructureNodeImportModel>();
+  recursiveFigmaFileStructureToMap(root, map);
+  return map;
+}
+
+function recursiveFigmaFileStructureToMap(
+  node: FigmaFileStructureNodeImportModel,
+  map: Map<string, FigmaFileStructureNodeImportModel>
+) {
+  map.set(node.id, node);
+  for (const child of node.children) recursiveFigmaFileStructureToMap(child, map);
+}

package/src/dsm/import/image.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { AssetScope } from "../assets";
+
+//
+// Abstract
+//
+
+export const ImageImportModelType = z.enum(["Url", "FigmaRender"]);
+export type ImageImportModelType = z.infer<typeof ImageImportModelType>;
+
+const ImageImportModelBase = z.object({
+  scope: AssetScope,
+});
+
+//
+// Url
+//
+
+export const UrlImageImportModel = ImageImportModelBase.extend({
+  type: z.literal(ImageImportModelType.enum.Url),
+  url: z.string(),
+  originKey: z.string(),
+  extension: z.enum(["png", "svg", "jpg"]),
+});
+
+export type UrlImageImportModel = z.infer<typeof UrlImageImportModel>;
+
+//
+// Figma Render
+//
+
+export const FigmaRenderFormat = z.enum(["Svg", "Png"]);
+
+const FigmaRenderBase = ImageImportModelBase.extend({
+  type: z.literal(ImageImportModelType.enum.FigmaRender),
+  fileId: z.string(),
+  fileVersionId: z.string().optional(),
+  nodeId: z.string(),
+  originKey: z.string(),
+});
+
+export const FigmaPngRenderImportModel = FigmaRenderBase.extend({
+  format: z.literal(FigmaRenderFormat.enum.Png),
+  scale: z.number(),
+});
+
+export const FigmaSvgRenderImportModel = FigmaRenderBase.extend({
+  format: z.literal(FigmaRenderFormat.enum.Svg),
+});
+
+export const FigmaRenderImportModel = z.discriminatedUnion("format", [
+  FigmaPngRenderImportModel,
+  FigmaSvgRenderImportModel,
+]);
+
+//
+// Union
+//
+
+// Unfortunately discriminated union doesn't support inserting another discriminated union
+export const ImageImportModel = z.union([UrlImageImportModel, FigmaRenderImportModel]);
+
+//
+// Types
+//
+
+export type FigmaRenderFormat = z.infer<typeof FigmaRenderFormat>;
+export type FigmaRenderBase = z.infer<typeof FigmaRenderBase>;
+export type FigmaPngRenderImportModel = z.infer<typeof FigmaPngRenderImportModel>;
+export type FigmaSvgRenderImportModel = z.infer<typeof FigmaSvgRenderImportModel>;
+export type FigmaRenderImportModel = z.infer<typeof FigmaRenderImportModel>;
+export type ImageImportModel = z.infer<typeof ImageImportModel>;

package/src/dsm/import/index.ts

@@ -0,0 +1,11 @@
+export * from "./support";
+export * from "./asset";
+export * from "./base";
+export * from "./component";
+export * from "./data-source";
+export * from "./figma-frames";
+export * from "./image";
+export * from "./origin";
+export * from "./theme";
+export * from "./tokens";
+export * from "./warning";

package/src/dsm/import/origin.ts

@@ -0,0 +1,5 @@
+export type DesignElementOriginImportModel = {
+  id: string;
+  name: string;
+  sourceId: string;
+};

package/src/dsm/import/support/figma-files.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const FigmaFileDownloadScope = z.object({
+  styles: z.boolean(),
+  components: z.boolean(),
+  currentVersion: z.literal("__latest__").nullable(),
+  publishedVersion: z.string().nullable(),
+  downloadChunkSize: z.number().optional(),
+});
+
+export const FigmaFileAccessData = z.object({
+  accessToken: z.string(),
+});
+
+export type FigmaFileDownloadScope = z.infer<typeof FigmaFileDownloadScope>;
+export type FigmaFileAccessData = z.infer<typeof FigmaFileAccessData>;

package/src/dsm/import/support/import-context.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { DataSourceFigmaImportMetadata, DataSourceFigmaRemote } from "../../data-sources";
+import { FigmaFileAccessData, FigmaFileDownloadScope } from "./figma-files";
+
+//
+// Importer payload
+//
+
+export const ImportFunctionInput = z.object({
+  importJobId: z.string(),
+  importContextId: z.string(),
+  designSystemId: z.string().optional(),
+});
+
+export type ImportFunctionInput = z.infer<typeof ImportFunctionInput>;
+
+//
+// Base context
+//
+
+export const ImportedFigmaSourceData = z.object({
+  sourceId: z.string(),
+  figmaRemote: DataSourceFigmaRemote,
+});
+
+export const FigmaImportBaseContext = z.object({
+  designSystemId: z.string(),
+
+  /**
+   * Data required for accessing Figma files. This should contain access data for all file ids
+   * mentioned in the `importedSourceDataBySourceId`
+   *
+   * fileId: file data
+   */
+  fileAccessByFileId: z.record(FigmaFileAccessData),
+
+  /**
+   * Figma source data for which import was requested
+   *
+   * sourceId: source data
+   */
+  importedSourceDataBySourceId: z.record(ImportedFigmaSourceData),
+});
+
+export type ImportedFigmaSourceData = z.infer<typeof ImportedFigmaSourceData>;
+export type FigmaImportBaseContext = z.infer<typeof FigmaImportBaseContext>;
+
+//
+// Context with file download scope
+//
+
+export const ChangedImportedFigmaSourceData = ImportedFigmaSourceData.extend({
+  importMetadata: DataSourceFigmaImportMetadata,
+});
+
+export const FigmaImportContextWithDownloadScopes = FigmaImportBaseContext.extend({
+  /**
+   * Describes what to download from each file, this should contain all file id mentioned in
+   * importMetadataBySourceId.
+   *
+   * File id -> file download scope
+   */
+  fileDownloadScopesByFileId: z.record(FigmaFileDownloadScope),
+
+  /**
+   * Sources filtered down to the ones that have changed since last import and therefore need to be
+   * imported again.
+   *
+   * Source id -> import metadata
+   */
+  changedImportedSourceDataBySourceId: z.record(ChangedImportedFigmaSourceData),
+});
+
+export type ChangedImportedFigmaSourceData = z.infer<typeof ChangedImportedFigmaSourceData>;
+export type FigmaImportContextWithDownloadScopes = z.infer<typeof FigmaImportContextWithDownloadScopes>;

package/src/dsm/import/support/import-model-collections.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { AssetImportModelInput, ComponentImportModel, ComponentImportModelInput } from "../component";
+import { ThemeImportModel, ThemeImportModelInput, ThemeUpdateImportModel, ThemeUpdateImportModelInput } from "../theme";
+import { DesignTokenImportModel, DesignTokenImportModelInput } from "../tokens";
+import { FigmaFileStructureImportModel, FigmaFileStructureImportModelInput } from "../figma-frames";
+import { DataSourceImportModel } from "../data-source";
+
+//
+// Collections
+//
+
+export const ImportModelInputCollection = z.object({
+  source: DataSourceImportModel,
+  tokens: z.array(DesignTokenImportModelInput).default([]),
+  components: z.array(ComponentImportModelInput).default([]),
+  assets: z.array(AssetImportModelInput).default([]),
+  themeUpdates: z.array(ThemeUpdateImportModelInput).default([]),
+  themes: z.array(ThemeImportModelInput).default([]),
+  figmaFileStructure: FigmaFileStructureImportModelInput.optional(),
+});
+
+export const ImportModelCollection = z.object({
+  sources: z.array(DataSourceImportModel),
+  tokens: z.array(DesignTokenImportModel).default([]),
+  components: z.array(ComponentImportModel).default([]),
+  themeUpdates: z.array(ThemeUpdateImportModel).default([]),
+  themes: z.array(ThemeImportModel).default([]),
+  figmaFileStructures: z.array(FigmaFileStructureImportModel),
+});
+
+export type ImportModelCollection = z.infer<typeof ImportModelCollection>;
+export type ImportModelInputCollection = z.infer<typeof ImportModelInputCollection>;
+
+export function addImportModelCollections(
+  lhs: ImportModelCollection,
+  rhs: ImportModelCollection
+): ImportModelCollection {
+  return {
+    sources: [...lhs.sources, ...rhs.sources],
+    tokens: [...lhs.tokens, ...rhs.tokens],
+    components: [...lhs.components, ...rhs.components],
+    themeUpdates: [...lhs.themeUpdates, ...rhs.themeUpdates],
+    themes: [...lhs.themes, ...rhs.themes],
+    figmaFileStructures: [...lhs.figmaFileStructures, ...rhs.figmaFileStructures],
+  };
+}

package/src/dsm/import/support/index.ts

@@ -0,0 +1,3 @@
+export * from "./figma-files";
+export * from "./import-context";
+export * from "./import-model-collections";

package/src/dsm/import/theme.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { DesignTokenTypedData } from "../elements";
+import { DesignTokenType } from "../elements";
+import { ThemeOriginObject, ThemeOriginSource, ThemeOverrideOrigin, ThemeOverrideOriginPart } from "../elements";
+import { ObjectMeta } from "../../common";
+
+//
+// Overrides
+//
+
+export const ThemeOverrideImportModelBase = DesignTokenTypedData.and(
+  z.object({
+    id: z.string(),
+    meta: ObjectMeta,
+  })
+);
+
+export const ThemeOverrideImportModel = ThemeOverrideImportModelBase.and(
+  z.object({
+    origin: ThemeOverrideOrigin,
+  })
+);
+
+export const ThemeOverrideImportModelInput = ThemeOverrideImportModelBase.and(
+  z.object({
+    originId: z.string(),
+    originMetadata: ThemeOverrideOriginPart,
+  })
+);
+
+export type ThemeOverrideImportModel = z.infer<typeof ThemeOverrideImportModel>;
+export type ThemeOverrideImportModelOfType<T extends DesignTokenType> = Extract<ThemeOverrideImportModel, { type: T }>;
+
+export type ThemeOverrideImportModelInput = z.infer<typeof ThemeOverrideImportModelInput>;
+export type ThemeOverrideImportModelInputOfType<T extends DesignTokenType> = Extract<
+  ThemeOverrideImportModelInput,
+  { type: T }
+>;
+
+//
+// Themes
+//
+
+export const ThemeImportModel = z.object({
+  meta: ObjectMeta,
+  brandPersistentId: z.string(),
+  originSource: ThemeOriginSource,
+  overrides: z.array(ThemeOverrideImportModel),
+  sortOrder: z.number(),
+});
+
+export const ThemeImportModelInput = z.object({
+  meta: ObjectMeta,
+  originObjects: z.array(ThemeOriginObject),
+  overrides: z.array(ThemeOverrideImportModelInput),
+});
+
+export type ThemeImportModel = z.infer<typeof ThemeImportModel>;
+export type ThemeImportModelInput = z.infer<typeof ThemeImportModelInput>;
+
+//
+// Theme Update
+//
+
+export const ThemeUpdateImportModel = z.object({
+  themePersistentId: z.string(),
+  overrides: z.array(ThemeOverrideImportModel),
+});
+
+export const ThemeUpdateImportModelInput = z.object({
+  themePersistentId: z.string(),
+  overrides: z.array(ThemeOverrideImportModelInput),
+});
+
+export type ThemeUpdateImportModel = z.infer<typeof ThemeUpdateImportModel>;
+export type ThemeUpdateImportModelInput = z.infer<typeof ThemeUpdateImportModelInput>;

package/src/dsm/import/tokens.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { DesignTokenType } from "../elements";
+import { DesignTokenOrigin, DesignTokenOriginPart, DesignTokenTypedData } from "../elements";
+import { ImportModelBase, ImportModelInputBase } from "./base";
+
+//
+// Base
+//
+
+const DesignTokenImportModelPart = z.object({
+  collection: z.string().optional(),
+});
+
+export const DesignTokenImportModelBase = ImportModelBase.extend(DesignTokenImportModelPart.shape).extend({
+  origin: DesignTokenOrigin,
+});
+
+export const DesignTokenImportModelInputBase = ImportModelInputBase.extend(DesignTokenImportModelPart.shape).extend({
+  originMetadata: DesignTokenOriginPart,
+});
+
+//
+// Import models
+//
+
+export const DesignTokenImportModel = DesignTokenTypedData.and(DesignTokenImportModelBase);
+export const DesignTokenImportModelInput = DesignTokenTypedData.and(DesignTokenImportModelInputBase);
+
+export type DesignTokenImportModelInputBase = z.infer<typeof DesignTokenImportModelInputBase>;
+
+export type DesignTokenImportModel = z.infer<typeof DesignTokenImportModel>;
+export type DesignTokenImportModelOfType<T extends DesignTokenType> = Extract<DesignTokenImportModel, { type: T }>;
+
+export type DesignTokenImportModelInput = z.infer<typeof DesignTokenImportModelInput>;
+export type DesignTokenImportModelInputOfType<T extends DesignTokenType> = Extract<DesignTokenImportModel, { type: T }>;
+
+export function isDesignTokenImportModelOfType<T extends DesignTokenType>(
+  designToken: DesignTokenImportModel,
+  type: T
+): designToken is DesignTokenImportModelOfType<T> {
+  return designToken.type === type;
+}
+
+export function designTokenImportModelTypeFilter<T extends DesignTokenType>(
+  type: T
+): (designToken: DesignTokenImportModel) => designToken is DesignTokenImportModelOfType<T> {
+  return (designToken): designToken is DesignTokenImportModelOfType<T> =>
+    isDesignTokenImportModelOfType(designToken, type);
+}

package/src/dsm/import/warning.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+export const ImportWarningType = z.enum([
+  "NoVersionFound",
+  "UnsupportedFill",
+  "UnsupportedStroke",
+  "UnsupportedEffect",
+  "NoPublishedElements",
+  "NoPublishedStyles",
+  "NoPublishedComponents",
+  "NoPublishedAssets",
+  "StyleNotApplied",
+  "ComponentHasNoThumbnail",
+  "DuplicateImportedStyleId",
+  "DuplicateImportedStylePath",
+]);
+
+export const ImportWarning = z.object({
+  warningType: ImportWarningType,
+  componentId: z.string().optional(),
+  componentName: z.string().optional(),
+  styleId: z.string().optional(),
+  styleName: z.string().optional(),
+  unsupportedStyleValueType: z.string().optional(),
+});
+
+export type ImportWarningType = z.infer<typeof ImportWarningType>;
+export type ImportWarning = z.infer<typeof ImportWarning>;

package/src/dsm/index.ts

@@ -0,0 +1,15 @@
+export * from "./assets";
+export * from "./data-sources";
+export * from "./documentation";
+export * from "./elements";
+export * from "./import";
+export * from "./properties";
+export * from "./views";
+export * from "./brand";
+export * from "./design-system";
+export * from "./desing-system-create";
+export * from "./desing-system-update";
+export * from "./published-doc-page";
+export * from "./published-doc";
+export * from "./reference";
+export * from "./version";

package/src/dsm/properties/index.ts

@@ -0,0 +1,3 @@
+export * from "./property-definition";
+export * from "./property-reference";
+export * from "./property-value";

package/src/dsm/properties/property-definition.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+
+export const ElementPropertyType = z.enum(["Text", "Number", "Boolean", "Select", "Generic", "Link", "URL"]);
+export const ElementPropertyTargetType = z.enum(["Token", "Component", "DocumentationPage"]);
+export const ElementPropertyLinkType = z.enum(["FigmaComponent", "DocumentationPage"]);
+
+export const ColorTokenInlineData = z.object({
+  value: z.string(),
+});
+
+export const ElementPropertyDefinitionOption = z.object({
+  id: z.string(),
+  name: z.string(),
+  backgroundColor: ColorTokenInlineData.optional(),
+});
+
+export const ElementPropertyDefinition = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  persistentId: z.string(),
+  name: z.string(),
+  codeName: z.string(),
+  description: z.string(),
+  type: ElementPropertyType,
+  targetElementType: ElementPropertyTargetType,
+  options: z.array(ElementPropertyDefinitionOption).nullish(),
+  linkElementType: ElementPropertyLinkType.nullish(),
+});
+
+export type ElementPropertyType = z.infer<typeof ElementPropertyType>;
+export type ElementPropertyTargetType = z.infer<typeof ElementPropertyTargetType>;
+export type ElementPropertyLinkType = z.infer<typeof ElementPropertyLinkType>;
+export type ColorTokenInlineData = z.infer<typeof ColorTokenInlineData>;
+export type ElementPropertyDefinitionOption = z.infer<typeof ElementPropertyDefinitionOption>;
+export type ElementPropertyDefinition = z.infer<typeof ElementPropertyDefinition>;
+
+export type CreateElementPropertyDefinition = DbCreateInputOmit<ElementPropertyDefinition>;
+export type UpdateElementPropertyDefinition = DbUpdate<ElementPropertyDefinition>;
+
+export type ElementPropertyDefinitionDiff = {
+  toCreate: CreateElementPropertyDefinition[];
+  toUpdate: UpdateElementPropertyDefinition[];
+};

package/src/dsm/properties/property-reference.ts

@@ -0,0 +1,5 @@
+export type ElementPropertyReference = {
+  id: string;
+  ownerId: string;
+  targetId: string;
+};

package/src/dsm/properties/property-value.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+
+export const ElementPropertyValue = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  targetElementPersistentId: z.string(),
+  definitionPersistentId: z.string(),
+  stringValue: z.string().nullish(),
+  numberValue: z.number().nullish(),
+  booleanValue: z.boolean().nullish(),
+  referenceValue: z.string().nullish(),
+  referenceValuePreview: z.string().nullish(),
+});
+
+export type ElementPropertyValue = z.infer<typeof ElementPropertyValue>;
+
+export type CreateElementPropertyValue = DbCreateInputOmit<ElementPropertyValue>;
+export type UpdateElementPropertyValue = OmitStrict<
+  DbUpdate<ElementPropertyValue>,
+  "designSystemVersionId" | "definitionPersistentId" | "targetElementPersistentId"
+>;
+
+export type ElementPropertyValueDiff = {
+  toCreate: CreateElementPropertyValue[];
+  toUpdate: UpdateElementPropertyValue[];
+};

package/src/dsm/published-doc-page.ts

@@ -0,0 +1,25 @@
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../helpers";
+
+export const SHORT_PERSISTENT_ID_LENGTH = 8;
+
+export function tryParseShortPersistentId(url = "/") {
+  const lastUrlPart = url.split("/").pop() || "";
+  const shortPersistentId = lastUrlPart.split("-").pop()?.replaceAll(".html", "") || null;
+
+  return shortPersistentId?.length === SHORT_PERSISTENT_ID_LENGTH ? shortPersistentId : null;
+}
+
+export type PublishedDocPage = {
+  id: string;
+  publishedDocId: string;
+  pageShortPersistentId: string;
+  pathV1: string;
+  pathV2: string;
+  storagePath: string;
+  createdAt: Date;
+  updatedAt: Date;
+  locale: string | undefined;
+};
+
+export type CreatePublishedDocPage = DbCreateInputOmit<PublishedDocPage>;
+export type UpdatePublishedDocPage = DbUpdate<OmitStrict<PublishedDocPage, "pageShortPersistentId" | "publishedDocId">>;

package/src/dsm/published-doc.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+export const publishedDocEnvironments = ["Live", "Preview"] as const;
+export const PublishedDocEnvironment = z.enum(publishedDocEnvironments);
+
+export const PublishedDocsChecksums = z.record(z.string());
+
+export const PublishedDocRoutingVersion = z.enum(["1", "2"]);
+
+export const PublishedDoc = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  lastPublishedAt: z.date(),
+  isDefault: z.boolean(),
+  isPublic: z.boolean(),
+  environment: PublishedDocEnvironment,
+  checksums: PublishedDocsChecksums,
+  storagePath: z.string(),
+  wasMigrated: z.boolean(),
+  routingVersion: PublishedDocRoutingVersion,
+  usesLocalizations: z.boolean(),
+  wasPublishedWithLocalizations: z.boolean(),
+});
+
+export type PublishedDocEnvironment = z.infer<typeof PublishedDocEnvironment>;
+export type PublishedDocsChecksums = z.infer<typeof PublishedDocsChecksums>;
+export type PublishedDocRoutingVersion = z.infer<typeof PublishedDocRoutingVersion>;
+export type PublishedDoc = z.infer<typeof PublishedDoc>;

package/src/dsm/reference.ts

@@ -0,0 +1,9 @@
+import { DbCreateInputOmit } from "../helpers";
+
+export type DesignElementReference = {
+  id: string;
+  ownerId: string;
+  referencedElementId: string;
+};
+
+export type CreateDesignElementReference = DbCreateInputOmit<DesignElementReference>;

package/src/dsm/version.ts

@@ -0,0 +1,14 @@
+export type DesignSystemVersion = {
+  id: string;
+  version: string;
+  createdAt: Date;
+  designSystemId: string;
+  name: string;
+  comment: string;
+  isReadonly: boolean;
+  parentId: string | null;
+  changeLog: string;
+
+  // TODO Artem
+  // customProperties: Prisma.JsonValue | null;
+};