@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/dto/workspaces/login-screen.ts

@@ -0,0 +1,42 @@
+import z from "zod";
+
+//
+// Entity
+//
+
+export const DTOLoginScreenSettings = z.object({
+  isEnabled: z.boolean(), // Flag to enable/disable the login screen
+  title: z.string().optional(),
+  color: z.string().optional(),
+  logoUrl: z.string().optional(),
+  isGoogleEnabled: z.boolean(), // Flag for Google login
+  isEmailEnabled: z.boolean(), // Flag for email login
+  isSsoEnabled: z.boolean(), // Flag for SSO login
+});
+
+export type DTOLoginScreenSettings = z.infer<typeof DTOLoginScreenSettings>;
+
+//
+// Payloads
+//
+
+export const DTOLoginScreenSettingsUpdate = DTOLoginScreenSettings.extend({
+  logoFileId: z.string().nullish(),
+  title: z.string().max(160, "Custom Login page title is too long. Maximum length is 160 characters.").nullish(),
+  color: z
+    .string()
+    .refine(
+      val => val === null || /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(val),
+      "Must be a valid hex color (e.g. #FF0000 or #FF000080) or null"
+    )
+    .nullish(),
+})
+  .omit({ logoUrl: true })
+  .partial();
+
+export const DTOLoginScreenSettingsResponse = z.object({
+  loginScreenSettings: DTOLoginScreenSettings,
+});
+
+export type DTOLoginScreenSettingsUpdate = z.infer<typeof DTOLoginScreenSettingsUpdate>;
+export type DTOLoginScreenSettingsResponse = z.infer<typeof DTOLoginScreenSettingsResponse>;

package/src/api/dto/workspaces/membership.ts

@@ -0,0 +1,55 @@
+import { User } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOWorkspaceRole, DTOWorkspaceSeatType } from "./enums";
+import { DTOWorkspace } from "./workspace";
+import { DTOUserNotificationSettings } from "../notifications/settings";
+
+//
+// Read
+//
+
+export const DTOUserWorkspaceMembership = z.object({
+  /** Workspace the user is a member of */
+  workspace: DTOWorkspace,
+
+  /** Assigned and stored role the user has in the workspace */
+  role: DTOWorkspaceRole,
+
+  /**  Role that determines actual permissions the user has in the workspace
+   * E.g. this is different from the default role when editors are downgraded to viewers
+   * when a workspace's subscription is downgraded to free tier
+   */
+  effectiveRole: DTOWorkspaceRole,
+
+  /** Assigned and stored seat type the user has in the workspace */
+  seatType: DTOWorkspaceSeatType,
+
+  /** Seat type that determines actual permissions the user has in the workspace. */
+  effectiveSeatType: DTOWorkspaceSeatType,
+
+  isDeactivated: z.boolean(),
+});
+
+export const DTOWorkspaceMember = z.object({
+  membershipId: z.string(),
+  user: User,
+  role: DTOWorkspaceRole,
+  effectiveRole: DTOWorkspaceRole,
+  seatType: DTOWorkspaceSeatType,
+  effectiveSeatType: DTOWorkspaceSeatType,
+  isDeactivated: z.boolean(),
+  notificationSettings: DTOUserNotificationSettings,
+});
+
+export const DTOUserWorkspaceMembershipsResponse = z.object({
+  membership: z.array(DTOUserWorkspaceMembership),
+});
+
+export const DTOWorkspaceMembersListResponse = z.object({
+  members: z.array(DTOWorkspaceMember),
+});
+
+export type DTOUserWorkspaceMembership = z.infer<typeof DTOUserWorkspaceMembership>;
+export type DTOWorkspaceMember = z.infer<typeof DTOWorkspaceMember>;
+export type DTOUserWorkspaceMembershipsResponse = z.infer<typeof DTOUserWorkspaceMembershipsResponse>;
+export type DTOWorkspaceMembersListResponse = z.infer<typeof DTOWorkspaceMembersListResponse>;

package/src/api/dto/workspaces/npm-registry.ts

@@ -0,0 +1,62 @@
+import { NpmRegistryAuthType, NpmRegistryType, nullishToOptional } from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTONpmRegistryConfigConstants = {
+  passwordPlaceholder: "redacted",
+};
+
+export const DTONpmRegistryConfig = z.object({
+  // Registry basic configuration
+  registryType: NpmRegistryType,
+  registryUrl: z.string(),
+  customRegistryUrl: z.string().optional(),
+
+  // URL of Supernova NPM packages proxy
+  proxyUrl: z.string(),
+
+  // Auth configuration
+  authType: NpmRegistryAuthType,
+  accessToken: z.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
+  username: z.string().optional(),
+  password: z.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
+
+  // NPM package scopes for whih the proxy should be enabled
+  enabledScopes: z.array(z.string()),
+
+  // True if client should bypass Supernova proxy and connect directly to the registry
+  // (e.g. when the NPM registry is behind a VPN or firewall which prevents Supernova from accessing it)
+  bypassProxy: z.boolean(),
+});
+
+export const DTONpmRegistryAccessTokenResponse = z.object({
+  version: z.number(),
+  accessToken: z.string().optional(),
+  registryUrl: z.string(),
+});
+
+export const DTOUpdateRegistryInput = z.object({
+  registryType: nullishToOptional(NpmRegistryType),
+  authType: nullishToOptional(NpmRegistryAuthType),
+  enabledScopes: nullishToOptional(z.array(z.string())),
+  customRegistryUrl: nullishToOptional(z.string()),
+  bypassProxy: nullishToOptional(z.boolean()),
+  npmProxyVersion: nullishToOptional(z.number()),
+  authHeaderName: nullishToOptional(z.string()),
+  authHeaderValue: nullishToOptional(z.string()),
+  accessToken: nullishToOptional(z.string()),
+  username: nullishToOptional(z.string()),
+  password: nullishToOptional(z.string()),
+});
+
+export const DTOUpdateRegistryOutput = z.object({
+  npmRegistrySettings: DTONpmRegistryConfig,
+});
+
+export type DTONpmRegistryConfig = z.infer<typeof DTONpmRegistryConfig>;
+export type DTONpmRegistryAccessTokenResponse = z.infer<typeof DTONpmRegistryAccessTokenResponse>;
+export type DTOUpdateRegistryInput = z.infer<typeof DTOUpdateRegistryInput>;
+export type DTOUpdateRegistryOutput = z.infer<typeof DTOUpdateRegistryOutput>;

package/src/api/dto/workspaces/products.ts

@@ -0,0 +1,45 @@
+import z from "zod";
+import { DTOBillingInterval, DTOProductCode, DTOWorkspaceBilledSeatType, DTOWorkspaceRole } from "./enums";
+
+//
+// Entities
+//
+
+export const DTOProductPrice = z.object({
+  isActive: z.boolean(),
+
+  /** @deprecated use `isActive` */
+  active: z.boolean(),
+  amount: z.number(),
+  interval: DTOBillingInterval,
+  isPricePerCreator: z.boolean(),
+  isTrial: z.boolean(),
+  isHidden: z.boolean(),
+  legacyVersion: z.string().optional(),
+  seatType: DTOWorkspaceBilledSeatType,
+  monthlyCreditGrant: z.number(),
+  stripePriceId: z.string(),
+  stripeProductId: z.string(),
+  stripeProductDescription: z.string().optional(),
+  stripeProductFeatures: z.string().array().optional(),
+  stripeProductAdditionalFeatures: z.string().array().optional(),
+});
+
+export const DTOProduct = z.object({
+  code: DTOProductCode,
+  allowedInviteRoles: DTOWorkspaceRole.array(),
+  prices: DTOProductPrice.array(),
+});
+
+export type DTOProductPrice = z.infer<typeof DTOProductPrice>;
+export type DTOProduct = z.infer<typeof DTOProduct>;
+
+//
+// Responses
+//
+
+export const DTOAvailableProductListResponse = z.object({
+  availablePlans: DTOProduct.array(),
+});
+
+export type DTOAvailableProductListResponse = z.infer<typeof DTOAvailableProductListResponse>;

package/src/api/dto/workspaces/subscription.ts

@@ -0,0 +1,170 @@
+import {
+  BillingTypeSchema,
+  CardSchema,
+  FeaturesSummary,
+  InternalStatusSchema,
+  ProductCodeSchema,
+  StripeSubscriptionStatusSchema,
+} from "@supernova-studio/model";
+import z from "zod";
+import { DTOBillingInterval, DTOWorkspaceRole } from "./enums";
+
+export const DTOCreditBalance = z.object({
+  paidTopUp: z
+    .object({
+      total: z.number(),
+      used: z.number(),
+      balance: z.number(),
+    })
+    .optional(),
+  paidRecurring: z
+    .object({
+      total: z.number(),
+      used: z.number(),
+      balance: z.number(),
+      resetAt: z.string().optional(),
+    })
+    .optional(),
+  free: z
+    .object({
+      credits: z.object({
+        total: z.number(),
+        used: z.number(),
+        balance: z.number(),
+        resetAt: z.string().optional(),
+      }),
+      spendingLimit: z.object({
+        total: z.number(),
+        used: z.number(),
+        balance: z.number(),
+        resetAt: z.string().optional(),
+      }),
+    })
+    .optional(),
+});
+
+export const DTOCreditsPrices = z.object({
+  creditsToCentsConversionRate: z.number(),
+  purchaseTopUpCreditsToCentsConversionRate: z.number(),
+});
+
+export const DTOSubscription = z.object({
+  stripeSubscriptionId: z.string().optional(),
+  stripeCustomerId: z.string().optional(),
+  stripeScheduleId: z.string().optional(),
+
+  status: InternalStatusSchema.optional(),
+  subscriptionStatus: StripeSubscriptionStatusSchema.optional(),
+  internalStatus: InternalStatusSchema.optional(),
+
+  product: ProductCodeSchema,
+  featuresSummary: FeaturesSummary.optional(),
+  allowedRoles: DTOWorkspaceRole.array(),
+
+  /**
+   * @deprecated get available-products for this information
+   */
+  stripeProductDescription: z.string().optional(),
+
+  /**
+   * @deprecated get available-products for this information
+   */
+  stripeProductFeatures: z.array(z.string()).optional(),
+
+  /**
+   * @deprecated get available-products for this information
+   */
+  stripeProductAdditionalFeatures: z.array(z.string()).optional(),
+
+  /**
+   * @deprecated always undefined
+   */
+  stripeSubscriptionMainItemId: z.string().optional(),
+
+  /**
+   * @deprecated use `fullSeatPriceId` or `builderSeatPriceId`
+   */
+  planPriceId: z.string(),
+  planInterval: DTOBillingInterval,
+
+  /**
+   * @deprecated All subscriptions were migrated to work as "price per creator"
+   */
+  isPricePerCreator: z.boolean().optional(),
+  legacyVersion: z.string().optional(),
+
+  seats: z.number(),
+  seatLimit: z.number(),
+
+  fullSeats: z.number(),
+  fullSeatLimit: z.number(),
+
+  builderSeats: z.number(),
+  builderSeatLimit: z.number(),
+
+  additionalCredits: z.number(),
+
+  currentPeriodStart: z.string().optional(),
+  currentPeriodEnd: z.string().optional(),
+  subscriptionStatusUpdatedAt: z.string().optional(),
+  cancelAt: z.string().nullish(),
+
+  card: CardSchema.optional(),
+
+  // New
+  amount: z.number(),
+  isTrial: z.boolean(),
+  billingType: BillingTypeSchema.optional(),
+  daysUntilDue: z.number().optional(),
+
+  fullSeatPriceId: z.string(),
+  builderSeatPriceId: z.string().optional(),
+  additionalCreditsPriceId: z.string().optional(),
+});
+
+export const DTOSubscriptionUpcomingChange = z.object({
+  effectiveAt: z.string(),
+  fullSeatLimit: z.number().optional(),
+  builderSeatLimit: z.number().optional(),
+  additionalCredits: z.number().optional(),
+});
+
+export const DTOSubscriptionResponse = z.object({
+  subscription: DTOSubscription,
+  subscriptionUpcomingChange: DTOSubscriptionUpcomingChange.optional(),
+  creditBalance: DTOCreditBalance.optional(),
+  creditsPrices: DTOCreditsPrices,
+});
+
+export const DTOSubscriptionUpdatePreview = z.object({
+  proration: z.object({
+    amount: z.number(),
+  }),
+  nextBillingCycle: z.object({
+    amount: z.number(),
+  }),
+});
+
+export const DTOSubscriptionUpdatePreviewResponse = z.object({
+  preview: DTOSubscriptionUpdatePreview,
+});
+
+export type DTOCreditBalance = z.infer<typeof DTOCreditBalance>;
+export type DTOSubscription = z.infer<typeof DTOSubscription>;
+export type DTOSubscriptionResponse = z.infer<typeof DTOSubscriptionResponse>;
+export type DTOCreditsPrices = z.infer<typeof DTOCreditsPrices>;
+export type DTOSubscriptionUpdatePreview = z.infer<typeof DTOSubscriptionUpdatePreview>;
+export type DTOSubscriptionUpdatePreviewResponse = z.infer<typeof DTOSubscriptionUpdatePreviewResponse>;
+export type DTOSubscriptionUpcomingChange = z.infer<typeof DTOSubscriptionUpcomingChange>;
+
+//
+// Inputs
+//
+
+export const DTOSubscriptionUpdateInput = z.object({
+  additionalCredits: z.number(),
+  builderSeats: z.number(),
+  fullSeats: z.number(),
+});
+
+export type DTOSubscriptionUpdateInput = z.infer<typeof DTOSubscriptionUpdateInput>;

package/src/api/dto/workspaces/transfer-ownership.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const DTOTransferOwnershipPayload = z.object({
+  newOwnerId: z.string(),
+});
+
+export type DTOTransferOwnershipPayload = z.infer<typeof DTOTransferOwnershipPayload>;

package/src/api/dto/workspaces/untyped-data.ts

@@ -0,0 +1,35 @@
+import { WorkspaceUntypedData } from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTOWorkspaceUntypedData = WorkspaceUntypedData;
+
+export const DTOWorkspaceUntypedDataListResponse = z.object({
+  data: DTOWorkspaceUntypedData.array(),
+});
+
+export const DTOWorkspaceUntypedDataResponse = z.object({
+  data: DTOWorkspaceUntypedData,
+});
+
+export type DTOWorkspaceUntypedData = z.infer<typeof DTOWorkspaceUntypedData>;
+export type DTOWorkspaceUntypedDataListResponse = z.infer<typeof DTOWorkspaceUntypedDataListResponse>;
+export type DTOWorkspaceUntypedDataResponse = z.infer<typeof DTOWorkspaceUntypedDataResponse>;
+
+//
+// Write
+//
+
+export const DTOWorkspaceUntypedDataCreatePayload = z.object({
+  value: z.unknown(),
+});
+
+export const DTOWorkspaceUntypedDataUpdatePayload = z.object({
+  value: z.unknown(),
+});
+
+export type DTOWorkspaceUntypedDataCreatePayload = z.infer<typeof DTOWorkspaceUntypedDataCreatePayload>;
+export type DTOWorkspaceUntypedDataUpdatePayload = z.infer<typeof DTOWorkspaceUntypedDataUpdatePayload>;

package/src/api/dto/workspaces/workspace.ts

@@ -0,0 +1,49 @@
+import {
+  Subscription,
+  WorkspaceDefaultProjectAccessMode,
+  WorkspaceDefaultProjectRole,
+  WorkspaceProfile,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTONpmRegistryConfig } from "./npm-registry";
+
+//
+// Read
+//
+
+export const DTOWorkspaceProfile = WorkspaceProfile;
+export const DTOWorkspaceDefaultProjectAccessMode = WorkspaceDefaultProjectAccessMode;
+export const DTOWorkspaceDefaultProjectRole = WorkspaceDefaultProjectRole;
+
+export const DTOWorkspace = z.object({
+  id: z.string(),
+  profile: DTOWorkspaceProfile,
+  subscription: Subscription,
+  npmRegistry: DTONpmRegistryConfig.optional(),
+  aiFeaturesEnabled: z.boolean().default(false),
+  projectsEnabled: z.boolean().default(false),
+  defaultProjectAccessMode: DTOWorkspaceDefaultProjectAccessMode,
+  defaultProjectRole: DTOWorkspaceDefaultProjectRole,
+  aiAskFeaturesEnabled: z.boolean().default(false),
+  aiCustomInstruction: z.string().optional(),
+});
+
+export type DTOWorkspaceProfile = z.infer<typeof DTOWorkspaceProfile>;
+export type DTOWorkspaceDefaultProjectAccessMode = z.infer<typeof DTOWorkspaceDefaultProjectAccessMode>;
+export type DTOWorkspaceDefaultProjectRole = z.infer<typeof DTOWorkspaceDefaultProjectRole>;
+export type DTOWorkspace = z.infer<typeof DTOWorkspace>;
+
+//
+// Write
+//
+
+export const DTOWorkspaceCreateInput = z.object({
+  name: z.string(),
+});
+
+export const DTOWorkspaceResponse = z.object({
+  workspace: DTOWorkspace,
+});
+
+export type DTOWorkspaceCreateInput = z.infer<typeof DTOWorkspaceCreateInput>;
+export type DTOWorkspaceResponse = z.infer<typeof DTOWorkspaceResponse>;

package/src/api/endpoints/auth-tokens.ts

@@ -0,0 +1,28 @@
+import {
+  DTOAccessTokenCreatePayload,
+  DTOAccessTokenFullResponse,
+  DTOAccessTokenListResponse,
+  DTOAccessTokenResponse,
+} from "../dto";
+import { RequestExecutor } from "../transport/request-executor";
+
+export class AuthTokensEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  list() {
+    return this.requestExecutor.json("/auth/tokens", DTOAccessTokenListResponse);
+  }
+
+  create(body: DTOAccessTokenCreatePayload) {
+    return this.requestExecutor.json("/auth/tokens", DTOAccessTokenFullResponse, {
+      method: "POST",
+      body,
+    });
+  }
+
+  delete(id: string) {
+    return this.requestExecutor.json(`/auth/tokens/${id}`, DTOAccessTokenResponse, {
+      method: "DELETE",
+    });
+  }
+}

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

@@ -0,0 +1,16 @@
+import { RequestExecutor } from "../../transport";
+import { ExportersEndpoint } from "./exporters";
+import { ExporterJobsEndpoint } from "./jobs";
+import { PipelinesEndpoint } from "./pipelines";
+
+export class CodegenEndpoint {
+  readonly exporters: ExportersEndpoint;
+  readonly pipelines: PipelinesEndpoint;
+  readonly jobs: ExporterJobsEndpoint;
+
+  constructor(private readonly requestExecutor: RequestExecutor) {
+    this.pipelines = new PipelinesEndpoint(requestExecutor);
+    this.exporters = new ExportersEndpoint(requestExecutor);
+    this.jobs = new ExporterJobsEndpoint(requestExecutor);
+  }
+}

package/src/api/endpoints/codegen/ds-pipelines.ts

@@ -0,0 +1,37 @@
+import { DTOExportJobResponse, DTOPipelineListQuery, DTOPipelineListResponse, DTOPipelineResponse } from "../../dto";
+import { DTOPipelineCreateBody, DTOPipelineTriggerBody } from "../../payloads";
+import { RequestExecutor } from "../../transport";
+
+export class DesignSystemPipelinesEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  list(designSystemId: string, query: DTOPipelineListQuery) {
+    const queryWithStrings = Object.fromEntries(
+      Object.entries(query)
+        .filter(e => !!e[1])
+        .map(([k, v]) => [k, v.toString()])
+    );
+
+    return this.requestExecutor.json(`/design-systems/${designSystemId}/pipelines`, DTOPipelineListResponse, {
+      query: new URLSearchParams(queryWithStrings),
+    });
+  }
+
+  create(designSystemId: string, payload: DTOPipelineCreateBody) {
+    return this.requestExecutor.json(`/design-systems/${designSystemId}/pipelines`, DTOPipelineResponse, {
+      body: payload,
+      method: "POST",
+    });
+  }
+
+  trigger(designSystemId: string, pipelineId: string, payload: DTOPipelineTriggerBody) {
+    return this.requestExecutor.json(
+      `/design-systems/${designSystemId}/pipelines/${pipelineId}/trigger`,
+      DTOExportJobResponse,
+      {
+        body: payload,
+        method: "POST",
+      }
+    );
+  }
+}

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

@@ -0,0 +1,54 @@
+import { serializeQuery } from "../../../utils";
+import { z } from "zod";
+import {
+  DTOExporterCreateInput,
+  DTOExporterResponse,
+  DTOExporterListQuery,
+  DTOExporterListResponse,
+  DTOExporterDeprecationInput,
+  DTOExporter,
+} from "../../dto";
+import { RequestExecutor } from "../../transport";
+
+export class ExportersEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  add(workspaceId: string, body: DTOExporterCreateInput) {
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/exporters`, DTOExporterResponse, {
+      body,
+      method: "POST",
+    });
+  }
+
+  list(workspaceId: string, query?: DTOExporterListQuery) {
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/exporters`, DTOExporterListResponse, {
+      query: query ? serializeQuery(query) : undefined,
+    });
+  }
+
+  get(workspaceId: string, exporterId: string) {
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/exporters/${exporterId}`, DTOExporterResponse);
+  }
+
+  deprecate(workspaceId: string, exporterId: string, body: DTOExporterDeprecationInput) {
+    return this.requestExecutor.json(
+      `/codegen/workspaces/${workspaceId}/exporters/${exporterId}/deprecation`,
+      DTOExporter,
+      {
+        body,
+        method: "PUT",
+      }
+    );
+  }
+
+  pullChanges(workspaceId: string, exporterId: string) {
+    return this.requestExecutor.json(
+      `/codegen/workspaces/${workspaceId}/exporters/${exporterId}`,
+      DTOExporterResponse,
+      {
+        body: {},
+        method: "PUT",
+      }
+    );
+  }
+}

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

@@ -0,0 +1,5 @@
+export * from "./codegen";
+export * from "./ds-pipelines";
+export * from "./exporters";
+export * from "./jobs";
+export * from "./pipelines";

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { DTOExportJobResponseLegacy } from "../../dto";
+import { RequestExecutor } from "../../transport";
+
+export class ExporterJobsEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  list(workspaceId: string) {
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/jobs`, z.any());
+  }
+
+  get(workspaceId: string, jobId: string) {
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/jobs/${jobId}`, DTOExportJobResponseLegacy);
+  }
+}

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

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import {
+  DTOExportJobResponse,
+  DTOPipelineListQuery,
+  DTOPipelineListResponse,
+  DTOPipelineResponse,
+  DTOWorkspaceStats,
+} from "../../dto";
+import { DTOPipelineCreateBody, DTOPipelineTriggerBody, DTOPipelineUpdateBody } from "../../payloads";
+import { RequestExecutor } from "../../transport";
+
+export class PipelinesEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  list(workspaceId: string, query: DTOPipelineListQuery) {
+    const queryWithStrings = Object.fromEntries(
+      Object.entries(query)
+        .filter(e => !!e[1])
+        .map(([k, v]) => [k, v.toString()])
+    );
+
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/pipelines`, DTOPipelineListResponse, {
+      query: new URLSearchParams(queryWithStrings),
+    });
+  }
+
+  create(workspaceId: string, payload: DTOPipelineCreateBody) {
+    return this.requestExecutor.json(`/codegen/workspaces/${workspaceId}/pipelines`, DTOPipelineResponse, {
+      body: payload,
+      method: "POST",
+    });
+  }
+
+  update(designSystemId: string, pipelineId: string, payload: DTOPipelineUpdateBody) {
+    return this.requestExecutor.json(`/design-systems/${designSystemId}/pipelines/${pipelineId}`, DTOPipelineResponse, {
+      body: payload,
+      method: "PUT",
+    });
+  }
+
+  trigger(workspaceId: string, pipelineId: string, payload: DTOPipelineTriggerBody) {
+    return this.requestExecutor.json(
+      `/codegen/workspaces/${workspaceId}/pipelines/${pipelineId}/trigger`,
+      DTOExportJobResponse,
+      {
+        body: payload,
+        method: "POST",
+      }
+    );
+  }
+
+  stats(workspaceId: string) {
+    return this.requestExecutor.json(`/workspaces/${workspaceId}/stats`, DTOWorkspaceStats);
+  }
+}