@supernova-studio/client 0.58.8 → 0.58.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/client",
-  "version": "0.58.8",
+  "version": "0.58.10",
   "description": "Supernova Data Models",
   "source": "src/index.ts",
   "main": "dist/index.js",

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

@@ -10,6 +10,12 @@ import {
 } 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(),
@@ -36,7 +42,7 @@ export const DTODataSourceFigma = z.object({
   id: z.string(),
   type: z.literal(DataSourceRemoteType.Enum.Figma),
   fileName: z.string(),
-  scope: DataSourceFigmaScope,
+  scope: DTODataSourceFigmaScope,
   brandId: z.string(),
   themeId: z.string().nullish(),
   cloud: DTODataSourceFigmaCloud.nullish(),
@@ -104,7 +110,7 @@ export const DTODataSourcesListResponse = z.object({
   sources: z.array(DTODataSource),
 });
 
-export const DTODataSourceCreationResponse = z.object({
+export const DTODataSourceResponse = z.object({
   source: DTODataSource,
 });
 
@@ -112,5 +118,24 @@ export type DTODataSourceFigma = z.infer<typeof DTODataSourceFigma>;
 export type DTODataSourceTokenStudio = z.infer<typeof DTODataSourceTokenStudio>;
 export type DTODataSourceFigmaVariablesPlugin = z.infer<typeof DTODataSourceFigmaVariablesPlugin>;
 export type DTODataSource = z.infer<typeof DTODataSource>;
-export type DTODataSourceCreationResponse = z.infer<typeof DTODataSourceCreationResponse>;
+export type DTODataSourceResponse = z.infer<typeof DTODataSourceResponse>;
 export type DTODataSourcesListResponse = z.infer<typeof DTODataSourcesListResponse>;
+
+//
+// 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 type DTODataSourceFigmaScope = z.infer<typeof DTODataSourceFigmaScope>;
+export type DTODataSourceFigmaCreatePayload = z.infer<typeof DTODataSourceFigmaCreatePayload>;
+export type DTODataSourceFigmaImportPayload = z.infer<typeof DTODataSourceFigmaImportPayload>;

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

@@ -4,7 +4,6 @@ export * from "./contact";
 export * from "./data-source";
 export * from "./design-system";
 export * from "./elements-diff";
-export * from "./exporter-property";
 export * from "./figma-variables";
 export * from "./import-job";
 export * from "./members";

package/src/api/dto/elements/components/figma-component-group.ts

@@ -0,0 +1,19 @@
+import z from "zod";
+import { DTOObjectMeta } from "../../aux/meta";
+
+export const DTOFigmaComponentGroup = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  persistentId: z.string(),
+  isRoot: z.boolean(),
+  brandId: z.string(),
+  meta: DTOObjectMeta,
+  childrenIds: z.string().array(),
+});
+
+export const DTOFigmaComponentGroupListResponse = z.object({
+  groups: DTOFigmaComponentGroup.array(),
+});
+
+export type DTOFigmaComponentGroup = z.infer<typeof DTOFigmaComponentGroup>;
+export type DTOFigmaComponentGroupListResponse = z.infer<typeof DTOFigmaComponentGroupListResponse>;

package/src/api/dto/elements/components/index.ts

@@ -1 +1,2 @@
+export * from "./figma-component-group";
 export * from "./figma-component";

package/src/api/dto/elements/frame-node-structures/frame-node-structure.ts

@@ -0,0 +1,17 @@
+import { FigmaFileStructureOrigin, FigmaFileStructureStatistics } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOFrameNodeStructure = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+  origin: FigmaFileStructureOrigin,
+  assetsInFile: FigmaFileStructureStatistics,
+});
+
+export const DTOFrameNodeStructureListResponse = z.object({
+  structures: DTOFrameNodeStructure.array(),
+});
+
+export type DTOFrameNodeStructure = z.infer<typeof DTOFrameNodeStructure>;
+export type DTOFrameNodeStructureListResponse = z.infer<typeof DTOFrameNodeStructureListResponse>;

package/src/api/dto/elements/frame-node-structures/index.ts

@@ -0,0 +1 @@
+export * from "./frame-node-structure";

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

@@ -1,6 +1,7 @@
 export * from "./components";
 export * from "./documentation";
 export * from "./figma-nodes";
+export * from "./frame-node-structures";
 export * from "./properties";
 export * from "./elements-action-v2";
 export * from "./get-elements-v2";

package/src/api/dto/export/exporter-property.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+
+//
+// Primitives
+//
+
+const PrimitiveValue = z.number().or(z.boolean()).or(z.string());
+const ArrayValue = z.array(z.string());
+const ObjectValue = z.record(z.string());
+
+export const DTOExporterPropertyDefinitionValue = PrimitiveValue.or(ArrayValue).or(ObjectValue);
+export const DTOExporterPropertyType = z.enum(["Enum", "Boolean", "String", "Number", "Array", "Object"]);
+
+export type DTOExporterPropertyDefinitionValue = z.infer<typeof DTOExporterPropertyDefinitionValue>;
+export type DTOExporterPropertyType = z.infer<typeof DTOExporterPropertyType>;
+
+//
+// Property
+//
+
+const PropertyDefinitionBase = z.object({
+  key: z.string(),
+  title: z.string(),
+  description: z.string(),
+});
+
+export const DTOExporterPropertyDefinitionEnum = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Enum),
+  options: z.string().array(),
+  default: z.string(),
+});
+
+export const DTOExporterPropertyDefinitionBoolean = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Boolean),
+  default: z.boolean(),
+});
+
+export const DTOExporterPropertyDefinitionString = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.String),
+  default: z.string(),
+});
+
+export const DTOExporterPropertyDefinitionNumber = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Number),
+  default: z.number(),
+});
+
+export const DTOExporterPropertyDefinitionArray = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Array),
+  default: ArrayValue,
+});
+
+export const DTOExporterPropertyDefinitionObject = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Object),
+  default: ObjectValue,
+  allowedKeys: z
+    .object({
+      options: z.string().array(),
+    })
+    .optional(),
+  allowedValues: z
+    .object({
+      options: z.string().array(),
+    })
+    .optional(),
+});
+
+export const DTOExporterPropertyDefinition = z.discriminatedUnion("type", [
+  DTOExporterPropertyDefinitionEnum,
+  DTOExporterPropertyDefinitionBoolean,
+  DTOExporterPropertyDefinitionString,
+  DTOExporterPropertyDefinitionNumber,
+  DTOExporterPropertyDefinitionArray,
+  DTOExporterPropertyDefinitionObject,
+]);
+
+export const DTOExporterPropertyDefinitionsResponse = z.object({
+  properties: DTOExporterPropertyDefinition.array(),
+});
+
+export type DTOExporterPropertyDefinitionEnum = z.infer<typeof DTOExporterPropertyDefinitionEnum>;
+export type DTOExporterPropertyDefinitionBoolean = z.infer<typeof DTOExporterPropertyDefinitionBoolean>;
+export type DTOExporterPropertyDefinitionString = z.infer<typeof DTOExporterPropertyDefinitionString>;
+export type DTOExporterPropertyDefinitionNumber = z.infer<typeof DTOExporterPropertyDefinitionNumber>;
+export type DTOExporterPropertyDefinitionArray = z.infer<typeof DTOExporterPropertyDefinitionArray>;
+export type DTOExporterPropertyDefinitionObject = z.infer<typeof DTOExporterPropertyDefinitionObject>;
+export type DTOExporterPropertyDefinition = z.infer<typeof DTOExporterPropertyDefinition>;
+export type DTOExporterPropertyDefinitionsResponse = z.infer<typeof DTOExporterPropertyDefinitionsResponse>;
+
+//
+// Value
+//
+
+export const DTOExporterPropertyDefinitionValueMap = z.record(DTOExporterPropertyDefinitionValue);
+export type DTOExporterPropertyDefinitionValueMap = z.infer<typeof DTOExporterPropertyDefinitionValueMap>;

package/src/api/dto/export/exporter.ts

@@ -5,6 +5,7 @@ import {
   PulsarCustomBlock,
 } from "@supernova-studio/model";
 import { z } from "zod";
+import { DTOExporterPropertyDefinition } from "./exporter-property";
 
 //
 // Read
@@ -27,6 +28,7 @@ export const DTOExporter = z.object({
 
   iconURL: z.string().optional(),
   configurationProperties: PulsarContributionConfigurationProperty.array(),
+  properties: DTOExporterPropertyDefinition.array().optional(),
   customBlocks: PulsarCustomBlock.array(),
   blockVariants: z.record(z.string(), PulsarContributionVariant.array()),
 

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

@@ -1,3 +1,4 @@
+export * from "./exporter-property";
 export * from "./exporter";
 export * from "./filter";
 export * from "./job";

package/src/api/dto/export/job.ts

@@ -11,6 +11,7 @@ import {
   ObjectMeta,
 } from "@supernova-studio/model";
 import { z } from "zod";
+import { DTOExporterPropertyDefinitionValueMap } from "./exporter-property";
 
 export const DTOExportJobCreatedBy = z.object({
   userId: z.string(),
@@ -69,6 +70,8 @@ export const DTOExportJob = z.object({
   brandPersistentId: z.string().optional(),
   themePersistentId: z.string().optional(),
   themePersistentIds: z.string().array().optional(),
+
+  exporterConfiguration: DTOExporterPropertyDefinitionValueMap.optional(),
 });
 
 export const DTOExportJobResponse = z.object({

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

@@ -1,5 +1,6 @@
 import { ExportDestinationsMap, PipelineEventType } from "@supernova-studio/model";
 import { z } from "zod";
+import { DTOExporterPropertyDefinitionValueMap } from "./exporter-property";
 import { DTOExportJob } from "./job";
 
 export const DTOPipelineListQuery = z.object({
@@ -21,6 +22,8 @@ export const DTOPipeline = z.object({
   themePersistentId: z.string().optional(),
   themePersistentIds: z.string().array().optional(),
 
+  exporterConfiguration: DTOExporterPropertyDefinitionValueMap.optional(),
+
   ...ExportDestinationsMap.shape,
 
   latestJobs: DTOExportJob.array(),

package/src/api/endpoints/codegen/exporters.ts

@@ -1,3 +1,4 @@
+import { serializeQuery } from "../../../utils";
 import { DTOExporterListQuery, DTOExporterListResponse } from "../../dto";
 import { RequestExecutor } from "../../transport";
 
@@ -5,14 +6,8 @@ export class ExportersEndpoint {
   constructor(private readonly requestExecutor: RequestExecutor) {}
 
   list(workspaceId: string, query: DTOExporterListQuery) {
-    const queryWithStrings = Object.fromEntries(
-      Object.entries(query)
-        .filter(e => !!e[1])
-        .map(([k, v]) => [k, v.toString()])
-    );
-
     return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/exporters`, DTOExporterListResponse, {
-      query: new URLSearchParams(queryWithStrings),
+      query: serializeQuery(query),
     });
   }
 }

package/src/api/endpoints/design-system/sources.ts

@@ -1,10 +1,23 @@
 import { z } from "zod";
-import { DTODataSourcesListResponse } from "../../dto";
+import {
+  DTODataSourceFigmaCreatePayload,
+  DTODataSourceFigmaImportPayload,
+  DTODataSourceResponse,
+  DTODataSourcesListResponse,
+  DTOImportJobResponse,
+} from "../../dto";
 import { RequestExecutor } from "../../transport/request-executor";
 
 export class DesignSystemSourcesEndpoint {
   constructor(private readonly requestExecutor: RequestExecutor) {}
 
+  create(dsId: string, payload: DTODataSourceFigmaCreatePayload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourceResponse, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
   list(dsId: string) {
     return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourcesListResponse);
   }
@@ -12,4 +25,11 @@ export class DesignSystemSourcesEndpoint {
   delete(dsId: string, sourceId: string) {
     return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, z.any(), { method: "DELETE" });
   }
+
+  figmaImport(dsId: string, payload: DTODataSourceFigmaImportPayload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/cloud-import`, DTOImportJobResponse, {
+      method: "POST",
+      body: payload,
+    });
+  }
 }

package/src/api/endpoints/design-system/versions/elements-action.ts

@@ -2,97 +2,52 @@ import {
   DTOCreateDocumentationGroupInput,
   DTOCreateDocumentationPageInputV2,
   DTOCreateDocumentationTabInput,
-  DTODocumentationStructure,
-  DTODocumentationStructureItem,
+  DTOElementActionInput,
   DTOElementActionOutput,
+  DTOFigmaNodeRenderInput,
   DTOMoveDocumentationGroupInput,
   DTOUpdateDocumentationGroupInput,
   DTOUpdateDocumentationPageInputV2,
 } from "../../../dto";
 import { RequestExecutor } from "../../../transport/request-executor";
 
-export class ElementsActionsEndpoint {
+export class ElementsActionEndpoint {
   constructor(private readonly requestExecutor: RequestExecutor) {}
 
   async createDocPage(dsId: string, vId: string, input: DTOCreateDocumentationPageInputV2) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/elements-action`,
-      DTOElementActionOutput,
-      {
-        body: {
-          type: "DocumentationPageCreate",
-          input,
-        },
-        method: "POST",
-      }
-    );
+    return this.action(dsId, vId, { type: "DocumentationPageCreate", input });
   }
 
   async createDocGroup(dsId: string, vId: string, input: DTOCreateDocumentationGroupInput) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/elements-action`,
-      DTOElementActionOutput,
-      {
-        body: {
-          type: "DocumentationGroupCreate",
-          input,
-        },
-        method: "POST",
-      }
-    );
+    return this.action(dsId, vId, { type: "DocumentationGroupCreate", input });
   }
 
   async moveDocGroup(dsId: string, vId: string, input: DTOMoveDocumentationGroupInput) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/elements-action`,
-      DTOElementActionOutput,
-      {
-        body: {
-          type: "DocumentationGroupMove",
-          input,
-        },
-        method: "POST",
-      }
-    );
+    return this.action(dsId, vId, { type: "DocumentationGroupMove", input });
   }
 
   async updateDocPage(dsId: string, vId: string, input: DTOUpdateDocumentationPageInputV2) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/elements-action`,
-      DTOElementActionOutput,
-      {
-        body: {
-          type: "DocumentationPageUpdate",
-          input,
-        },
-        method: "POST",
-      }
-    );
+    return this.action(dsId, vId, { type: "DocumentationPageUpdate", input });
   }
 
   async updateDocGroup(dsId: string, vId: string, input: DTOUpdateDocumentationGroupInput) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/elements-action`,
-      DTOElementActionOutput,
-      {
-        body: {
-          type: "DocumentationGroupUpdate",
-          input,
-        },
-        method: "POST",
-      }
-    );
+    return this.action(dsId, vId, { type: "DocumentationGroupUpdate", input });
   }
 
   async createDocTab(dsId: string, vId: string, input: DTOCreateDocumentationTabInput) {
+    return this.action(dsId, vId, { type: "DocumentationTabCreate", input });
+  }
+
+  async renderNodes(dsId: string, vId: string, input: DTOFigmaNodeRenderInput[]) {
+    return this.action(dsId, vId, { type: "FigmaNodeRender", input });
+  }
+
+  private async action(dsId: string, vId: string, input: DTOElementActionInput) {
     return this.requestExecutor.json(
       `/design-systems/${dsId}/versions/${vId}/elements-action`,
       DTOElementActionOutput,
       {
-        body: {
-          type: "DocumentationTabCreate",
-          input,
-        },
+        body: input,
         method: "POST",
       }
     );

package/src/api/endpoints/design-system/versions/elements.ts

@@ -0,0 +1,13 @@
+import { serializeQuery } from "../../../../utils";
+import { DTOElementsGetOutput, DTOElementsGetQueryParsed } from "../../../dto";
+import { RequestExecutor } from "../../../transport/request-executor";
+
+export class ElementsEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  getElements(dsId: string, vId: string, query: DTOElementsGetQueryParsed) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/elements`, DTOElementsGetOutput, {
+      query: serializeQuery(query),
+    });
+  }
+}

package/src/api/endpoints/design-system/versions/figma-component-groups.ts

@@ -0,0 +1,13 @@
+import { DTOFigmaComponentGroupListResponse } from "../../../dto";
+import { RequestExecutor } from "../../../transport/request-executor";
+
+export class FigmaComponentGroupsEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  async list(dsId: string, vId: string) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/component-groups`,
+      DTOFigmaComponentGroupListResponse
+    );
+  }
+}

package/src/api/endpoints/design-system/versions/figma-components.ts

@@ -0,0 +1,13 @@
+import { DTOFigmaComponentListResponse } from "../../../dto";
+import { RequestExecutor } from "../../../transport/request-executor";
+
+export class FigmaComponentsEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  async list(dsId: string, vId: string) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/components`,
+      DTOFigmaComponentListResponse
+    );
+  }
+}

package/src/api/endpoints/design-system/versions/figma-frame-structures.ts

@@ -0,0 +1,13 @@
+import { DTOFrameNodeStructureListResponse } from "../../../dto";
+import { RequestExecutor } from "../../../transport/request-executor";
+
+export class FigmaFrameStructuresEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  list(dsId: string, vId: string) {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${vId}/figma-frames/node-structures`,
+      DTOFrameNodeStructureListResponse
+    );
+  }
+}

package/src/api/endpoints/design-system/versions/index.ts

@@ -1,8 +1,11 @@
 export * from "./brands";
-export * from "./components";
 export * from "./documentation";
+export * from "./ds-components";
 export * from "./elements-action";
-export * from "./elements-actions";
+export * from "./elements";
+export * from "./figma-component-groups";
+export * from "./figma-components";
+export * from "./figma-frame-structures";
 export * from "./import-jobs";
 export * from "./overrides";
 export * from "./property-definitions";

package/src/api/endpoints/design-system/versions/versions.ts

@@ -6,9 +6,13 @@ import {
 import { DTOCreateVersionInput } from "../../../payloads";
 import { RequestExecutor } from "../../../transport/request-executor";
 import { BrandsEndpoint } from "./brands";
-import { DesignSystemComponentEndpoint } from "./components";
 import { DocumentationEndpoint } from "./documentation";
-import { ElementsActionsEndpoint } from "./elements-actions";
+import { DesignSystemComponentEndpoint } from "./ds-components";
+import { ElementsEndpoint } from "./elements";
+import { ElementsActionEndpoint } from "./elements-action";
+import { FigmaComponentGroupsEndpoint } from "./figma-component-groups";
+import { FigmaComponentsEndpoint } from "./figma-components";
+import { FigmaFrameStructuresEndpoint } from "./figma-frame-structures";
 import { ImportJobsEndpoint } from "./import-jobs";
 import { ElementPropertyDefinitionsEndpoint } from "./property-definitions";
 import { ElementPropertyValuesEndpoint } from "./property-values";
@@ -25,10 +29,14 @@ export class DesignSystemVersionsEndpoint {
   readonly importJobs: ImportJobsEndpoint;
   readonly tokens: TokensEndpoint;
   readonly tokenGroups: TokenGroupsEndpoint;
+  readonly figmaComponents: FigmaComponentsEndpoint;
+  readonly figmaComponentGroups: FigmaComponentGroupsEndpoint;
+  readonly figmaFrameStructures: FigmaFrameStructuresEndpoint;
   readonly stats: VersionStatsEndpoint;
   readonly elementPropertyDefinitions: ElementPropertyDefinitionsEndpoint;
   readonly elementPropertyValues: ElementPropertyValuesEndpoint;
-  readonly elementsActions: ElementsActionsEndpoint;
+  readonly elementsAction: ElementsActionEndpoint;
+  readonly elements: ElementsEndpoint;
   readonly designSystemComponents: DesignSystemComponentEndpoint;
   readonly documentation: DocumentationEndpoint;
 
@@ -39,10 +47,14 @@ export class DesignSystemVersionsEndpoint {
     this.importJobs = new ImportJobsEndpoint(requestExecutor);
     this.tokens = new TokensEndpoint(requestExecutor);
     this.tokenGroups = new TokenGroupsEndpoint(requestExecutor);
+    this.figmaComponents = new FigmaComponentsEndpoint(requestExecutor);
+    this.figmaComponentGroups = new FigmaComponentGroupsEndpoint(requestExecutor);
+    this.figmaFrameStructures = new FigmaFrameStructuresEndpoint(requestExecutor);
     this.stats = new VersionStatsEndpoint(requestExecutor);
     this.elementPropertyDefinitions = new ElementPropertyDefinitionsEndpoint(requestExecutor);
     this.elementPropertyValues = new ElementPropertyValuesEndpoint(requestExecutor);
-    this.elementsActions = new ElementsActionsEndpoint(requestExecutor);
+    this.elementsAction = new ElementsActionEndpoint(requestExecutor);
+    this.elements = new ElementsEndpoint(requestExecutor);
     this.designSystemComponents = new DesignSystemComponentEndpoint(requestExecutor);
     this.documentation = new DocumentationEndpoint(requestExecutor);
   }

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

@@ -10,6 +10,7 @@ import {
   PipelineEventType,
 } from "@supernova-studio/model";
 import { z } from "zod";
+import { DTOExporterPropertyDefinitionValueMap } from "../../dto/export/exporter-property";
 
 export const DTOPipelineCreateBody = z.object({
   name: z.string(),
@@ -21,6 +22,8 @@ export const DTOPipelineCreateBody = z.object({
   themePersistentId: z.string().optional(),
   themePersistentIds: z.string().array().optional(),
 
+  exporterConfiguration: DTOExporterPropertyDefinitionValueMap.optional(),
+
   destination: PipelineDestinationType.optional(),
   gitQuery: GitObjectsQuery,
   destinations: z.object({

package/src/api/transport/request-executor.ts

@@ -68,6 +68,8 @@ export class RequestExecutor {
 
     const responseParseResult = schema.safeParse(wrapperParseResult.data.result);
     if (!responseParseResult.success) {
+      console.error(`Response was:`);
+      console.error(wrapperParseResult.data.result);
       throw RequestExecutorError.responseParsingError(endpoint, responseParseResult.error);
     }
 

package/src/utils/index.ts

@@ -1 +1,2 @@
 export * from "./hash";
+export * from "./query";

package/src/utils/query.ts

@@ -0,0 +1,18 @@
+type CompatibleValue = number | string | boolean | undefined;
+type QueryObject = Record<string, CompatibleValue | CompatibleValue[]>;
+
+export function serializeQuery(query: QueryObject): URLSearchParams {
+  const queryWithStrings = Object.fromEntries(
+    Object.entries(query)
+      .filter(e => !!e[1])
+      .map(([k, v]) => {
+        if (Array.isArray(v)) {
+          return [k, v.join(", ")];
+        } else {
+          return [k, v!.toString()];
+        }
+      })
+  );
+
+  return new URLSearchParams(queryWithStrings);
+}

package/src/api/dto/design-systems/exporter-property.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-
-export const DTOExporterProperty = z.any({});
-
-export const DTOExporterPropertyListResponse = z.object({ items: z.array(DTOExporterProperty) });
-
-export type DTOExporterProperty = z.infer<typeof DTOExporterProperty>;
-export type DTOExporterPropertyListResponse = z.infer<typeof DTOExporterPropertyListResponse>;

package/src/api/endpoints/design-system/versions/elements-actions.ts

@@ -1,20 +0,0 @@
-import { DTOCreateDocumentationPageInputV2, DTOElementActionOutput } from "../../../dto";
-import { RequestExecutor } from "../../../transport/request-executor";
-
-export class ElementsActionsEndpoint {
-  constructor(private readonly requestExecutor: RequestExecutor) {}
-
-  async createDocPage(dsId: string, vId: string, input: DTOCreateDocumentationPageInputV2) {
-    return this.requestExecutor.json(
-      `/design-systems/${dsId}/versions/${vId}/elements-action`,
-      DTOElementActionOutput,
-      {
-        body: {
-          type: "DocumentationPageCreate",
-          input,
-        },
-        method: "POST",
-      }
-    );
-  }
-}