@supernova-studio/client 0.58.12 → 0.58.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/index.js +9 -0
  2. package/dist/index.js.map +1 -1
  3. package/dist/index.mjs +1387 -1378
  4. package/dist/index.mjs.map +1 -1
  5. package/package.json +1 -1
package/dist/index.mjs CHANGED
@@ -20,12 +20,12 @@ import { z as z11 } from "zod";
20
20
  import { z as z12 } from "zod";
21
21
  import { z as z13 } from "zod";
22
22
  import { z as z14 } from "zod";
23
- import { z as z146 } from "zod";
23
+ import { z as z147 } from "zod";
24
24
  import { z as z17 } from "zod";
25
25
  import { z as z15 } from "zod";
26
26
  import { z as z16 } from "zod";
27
+ import { z as z146 } from "zod";
27
28
  import { z as z145 } from "zod";
28
- import { z as z144 } from "zod";
29
29
  import { z as z18 } from "zod";
30
30
  import { z as z19 } from "zod";
31
31
  import { z as z20 } from "zod";
@@ -154,36 +154,37 @@ import { z as z140 } from "zod";
154
154
  import { z as z141 } from "zod";
155
155
  import { z as z142 } from "zod";
156
156
  import { z as z143 } from "zod";
157
+ import { z as z144 } from "zod";
158
+ import { z as z154 } from "zod";
157
159
  import { z as z153 } from "zod";
158
- import { z as z152 } from "zod";
159
- import { z as z147 } from "zod";
160
160
  import { z as z148 } from "zod";
161
161
  import { z as z149 } from "zod";
162
162
  import { z as z150 } from "zod";
163
163
  import { z as z151 } from "zod";
164
+ import { z as z152 } from "zod";
165
+ import { z as z157 } from "zod";
164
166
  import { z as z156 } from "zod";
165
167
  import { z as z155 } from "zod";
166
- import { z as z154 } from "zod";
167
- import { z as z157 } from "zod";
168
168
  import { z as z158 } from "zod";
169
169
  import { z as z159 } from "zod";
170
- import { z as z162 } from "zod";
171
170
  import { z as z160 } from "zod";
172
- import { z as z161 } from "zod";
173
171
  import { z as z163 } from "zod";
172
+ import { z as z161 } from "zod";
173
+ import { z as z162 } from "zod";
174
174
  import { z as z164 } from "zod";
175
175
  import { z as z165 } from "zod";
176
176
  import { z as z166 } from "zod";
177
177
  import { z as z167 } from "zod";
178
178
  import { z as z168 } from "zod";
179
- import { z as z170 } from "zod";
180
179
  import { z as z169 } from "zod";
181
180
  import { z as z171 } from "zod";
181
+ import { z as z170 } from "zod";
182
182
  import { z as z172 } from "zod";
183
183
  import { z as z173 } from "zod";
184
184
  import { z as z174 } from "zod";
185
185
  import { z as z175 } from "zod";
186
186
  import { z as z176 } from "zod";
187
+ import { z as z177 } from "zod";
187
188
  var __defProp2 = Object.defineProperty;
188
189
  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
189
190
  var __publicField2 = (obj, key, value) => {
@@ -4038,143 +4039,151 @@ var ExporterPropertyValuesCollection = z140.object({
4038
4039
  exporterId: z140.string(),
4039
4040
  values: z140.array(ExporterPropertyValue)
4040
4041
  });
4041
- var PublishedDocPage = z141.object({
4042
+ var PublishedDocPageVisitsEntry = z141.object({
4042
4043
  id: z141.string(),
4043
- publishedDocId: z141.string(),
4044
+ versionId: z141.string(),
4044
4045
  pageShortPersistentId: z141.string(),
4045
- pathV1: z141.string(),
4046
- pathV2: z141.string(),
4047
- storagePath: z141.string(),
4048
4046
  locale: z141.string().optional(),
4049
- isPrivate: z141.boolean(),
4050
- isHidden: z141.boolean(),
4051
- createdAt: z141.coerce.date(),
4052
- updatedAt: z141.coerce.date()
4047
+ timestamp: z141.coerce.date(),
4048
+ visits: z141.number()
4053
4049
  });
4054
- var publishedDocEnvironments = ["Live", "Preview"];
4055
- var PublishedDocEnvironment = z142.enum(publishedDocEnvironments);
4056
- var PublishedDocsChecksums = z142.record(z142.string());
4057
- var PublishedDocRoutingVersion = z142.enum(["1", "2"]);
4058
- var PublishedDoc = z142.object({
4050
+ var PublishedDocPage = z142.object({
4059
4051
  id: z142.string(),
4060
- designSystemVersionId: z142.string(),
4061
- createdAt: z142.coerce.date(),
4062
- updatedAt: z142.coerce.date(),
4063
- lastPublishedAt: z142.coerce.date(),
4064
- isDefault: z142.boolean(),
4065
- isPublic: z142.boolean(),
4066
- environment: PublishedDocEnvironment,
4067
- checksums: PublishedDocsChecksums,
4052
+ publishedDocId: z142.string(),
4053
+ pageShortPersistentId: z142.string(),
4054
+ pathV1: z142.string(),
4055
+ pathV2: z142.string(),
4068
4056
  storagePath: z142.string(),
4069
- wasMigrated: z142.boolean(),
4070
- routingVersion: PublishedDocRoutingVersion,
4071
- usesLocalizations: z142.boolean(),
4072
- wasPublishedWithLocalizations: z142.boolean(),
4073
- tokenCount: z142.number(),
4074
- assetCount: z142.number()
4057
+ locale: z142.string().optional(),
4058
+ isPrivate: z142.boolean(),
4059
+ isHidden: z142.boolean(),
4060
+ createdAt: z142.coerce.date(),
4061
+ updatedAt: z142.coerce.date()
4075
4062
  });
4076
- var DesignSystemVersion = z143.object({
4063
+ var publishedDocEnvironments = ["Live", "Preview"];
4064
+ var PublishedDocEnvironment = z143.enum(publishedDocEnvironments);
4065
+ var PublishedDocsChecksums = z143.record(z143.string());
4066
+ var PublishedDocRoutingVersion = z143.enum(["1", "2"]);
4067
+ var PublishedDoc = z143.object({
4077
4068
  id: z143.string(),
4078
- version: z143.string(),
4069
+ designSystemVersionId: z143.string(),
4079
4070
  createdAt: z143.coerce.date(),
4080
- designSystemId: z143.string(),
4081
- name: z143.string(),
4082
- comment: z143.string(),
4083
- isReadonly: z143.boolean(),
4084
- changeLog: z143.string(),
4085
- parentId: z143.string().optional(),
4086
- isDraftsFeatureAdopted: z143.boolean()
4087
- });
4088
- var VersionCreationJobStatus = z143.enum(["Success", "InProgress", "Error"]);
4089
- var VersionCreationJob = z143.object({
4090
- id: z143.string(),
4091
- version: z143.string(),
4092
- designSystemId: z143.string(),
4093
- designSystemVersionId: nullishToOptional(z143.string()),
4071
+ updatedAt: z143.coerce.date(),
4072
+ lastPublishedAt: z143.coerce.date(),
4073
+ isDefault: z143.boolean(),
4074
+ isPublic: z143.boolean(),
4075
+ environment: PublishedDocEnvironment,
4076
+ checksums: PublishedDocsChecksums,
4077
+ storagePath: z143.string(),
4078
+ wasMigrated: z143.boolean(),
4079
+ routingVersion: PublishedDocRoutingVersion,
4080
+ usesLocalizations: z143.boolean(),
4081
+ wasPublishedWithLocalizations: z143.boolean(),
4082
+ tokenCount: z143.number(),
4083
+ assetCount: z143.number()
4084
+ });
4085
+ var DesignSystemVersion = z144.object({
4086
+ id: z144.string(),
4087
+ version: z144.string(),
4088
+ createdAt: z144.coerce.date(),
4089
+ designSystemId: z144.string(),
4090
+ name: z144.string(),
4091
+ comment: z144.string(),
4092
+ isReadonly: z144.boolean(),
4093
+ changeLog: z144.string(),
4094
+ parentId: z144.string().optional(),
4095
+ isDraftsFeatureAdopted: z144.boolean()
4096
+ });
4097
+ var VersionCreationJobStatus = z144.enum(["Success", "InProgress", "Error"]);
4098
+ var VersionCreationJob = z144.object({
4099
+ id: z144.string(),
4100
+ version: z144.string(),
4101
+ designSystemId: z144.string(),
4102
+ designSystemVersionId: nullishToOptional(z144.string()),
4094
4103
  status: VersionCreationJobStatus,
4095
- errorMessage: nullishToOptional(z143.string())
4104
+ errorMessage: nullishToOptional(z144.string())
4096
4105
  });
4097
4106
  var BITBUCKET_SLUG = /^[-a-zA-Z0-9~]*$/;
4098
4107
  var BITBUCKET_MAX_LENGTH = 64;
4099
- var ExportJobDocumentationChanges = z144.object({
4100
- pagePersistentIds: z144.string().array(),
4101
- groupPersistentIds: z144.string().array()
4108
+ var ExportJobDocumentationChanges = z145.object({
4109
+ pagePersistentIds: z145.string().array(),
4110
+ groupPersistentIds: z145.string().array()
4102
4111
  });
4103
- var ExporterDestinationDocs = z144.object({
4112
+ var ExporterDestinationDocs = z145.object({
4104
4113
  environment: PublishedDocEnvironment,
4105
4114
  changes: nullishToOptional(ExportJobDocumentationChanges)
4106
4115
  });
4107
- var ExporterDestinationS3 = z144.object({});
4108
- var ExporterDestinationGithub = z144.object({
4109
- credentialId: z144.string().optional(),
4116
+ var ExporterDestinationS3 = z145.object({});
4117
+ var ExporterDestinationGithub = z145.object({
4118
+ credentialId: z145.string().optional(),
4110
4119
  // Repository
4111
- url: z144.string(),
4120
+ url: z145.string(),
4112
4121
  // Location
4113
- branch: z144.string(),
4114
- relativePath: nullishToOptional(z144.string()),
4115
- purgeDirectory: nullishToOptional(z144.boolean()),
4122
+ branch: z145.string(),
4123
+ relativePath: nullishToOptional(z145.string()),
4124
+ purgeDirectory: nullishToOptional(z145.boolean()),
4116
4125
  // Commit metadata
4117
- commitAuthorName: nullishToOptional(z144.string()),
4118
- commitAuthorEmail: nullishToOptional(z144.string()),
4126
+ commitAuthorName: nullishToOptional(z145.string()),
4127
+ commitAuthorEmail: nullishToOptional(z145.string()),
4119
4128
  // Legacy deprecated fields. Use `credentialId` instead
4120
- connectionId: nullishToOptional(z144.string()),
4121
- userId: nullishToOptional(z144.number())
4129
+ connectionId: nullishToOptional(z145.string()),
4130
+ userId: nullishToOptional(z145.number())
4122
4131
  });
4123
- var ExporterDestinationAzure = z144.object({
4124
- credentialId: z144.string().optional(),
4132
+ var ExporterDestinationAzure = z145.object({
4133
+ credentialId: z145.string().optional(),
4125
4134
  // Repository
4126
- organizationId: z144.string(),
4127
- projectId: z144.string(),
4128
- repositoryId: z144.string(),
4135
+ organizationId: z145.string(),
4136
+ projectId: z145.string(),
4137
+ repositoryId: z145.string(),
4129
4138
  // Commit metadata
4130
- commitAuthorName: nullishToOptional(z144.string()),
4131
- commitAuthorEmail: nullishToOptional(z144.string()),
4139
+ commitAuthorName: nullishToOptional(z145.string()),
4140
+ commitAuthorEmail: nullishToOptional(z145.string()),
4132
4141
  // Location
4133
- branch: z144.string(),
4134
- relativePath: nullishToOptional(z144.string()),
4135
- purgeDirectory: nullishToOptional(z144.boolean()),
4142
+ branch: z145.string(),
4143
+ relativePath: nullishToOptional(z145.string()),
4144
+ purgeDirectory: nullishToOptional(z145.boolean()),
4136
4145
  // Maybe not needed
4137
- url: nullishToOptional(z144.string()),
4146
+ url: nullishToOptional(z145.string()),
4138
4147
  // Legacy deprecated fields. Use `credentialId` instead
4139
- connectionId: nullishToOptional(z144.string()),
4140
- userId: nullishToOptional(z144.number())
4148
+ connectionId: nullishToOptional(z145.string()),
4149
+ userId: nullishToOptional(z145.number())
4141
4150
  });
4142
- var ExporterDestinationGitlab = z144.object({
4143
- credentialId: z144.string().optional(),
4151
+ var ExporterDestinationGitlab = z145.object({
4152
+ credentialId: z145.string().optional(),
4144
4153
  // Repository
4145
- projectId: z144.string(),
4154
+ projectId: z145.string(),
4146
4155
  // Commit metadata
4147
- commitAuthorName: nullishToOptional(z144.string()),
4148
- commitAuthorEmail: nullishToOptional(z144.string()),
4156
+ commitAuthorName: nullishToOptional(z145.string()),
4157
+ commitAuthorEmail: nullishToOptional(z145.string()),
4149
4158
  // Location
4150
- branch: z144.string(),
4151
- relativePath: nullishToOptional(z144.string()),
4152
- purgeDirectory: nullishToOptional(z144.boolean()),
4159
+ branch: z145.string(),
4160
+ relativePath: nullishToOptional(z145.string()),
4161
+ purgeDirectory: nullishToOptional(z145.boolean()),
4153
4162
  // Maybe not needed
4154
- url: nullishToOptional(z144.string()),
4163
+ url: nullishToOptional(z145.string()),
4155
4164
  // Legacy deprecated fields. Use `credentialId` instead
4156
- connectionId: nullishToOptional(z144.string()),
4157
- userId: nullishToOptional(z144.number())
4165
+ connectionId: nullishToOptional(z145.string()),
4166
+ userId: nullishToOptional(z145.number())
4158
4167
  });
4159
- var ExporterDestinationBitbucket = z144.object({
4160
- credentialId: z144.string().optional(),
4168
+ var ExporterDestinationBitbucket = z145.object({
4169
+ credentialId: z145.string().optional(),
4161
4170
  // Repository
4162
- workspaceSlug: z144.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
4163
- projectKey: z144.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
4164
- repoSlug: z144.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
4171
+ workspaceSlug: z145.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
4172
+ projectKey: z145.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
4173
+ repoSlug: z145.string().max(BITBUCKET_MAX_LENGTH).regex(BITBUCKET_SLUG),
4165
4174
  // Commit metadata
4166
- commitAuthorName: nullishToOptional(z144.string()),
4167
- commitAuthorEmail: nullishToOptional(z144.string()),
4175
+ commitAuthorName: nullishToOptional(z145.string()),
4176
+ commitAuthorEmail: nullishToOptional(z145.string()),
4168
4177
  // Location
4169
- branch: z144.string(),
4170
- relativePath: nullishToOptional(z144.string()),
4171
- purgeDirectory: nullishToOptional(z144.boolean()),
4178
+ branch: z145.string(),
4179
+ relativePath: nullishToOptional(z145.string()),
4180
+ purgeDirectory: nullishToOptional(z145.boolean()),
4172
4181
  // Legacy deprecated fields. Use `credentialId` instead
4173
- connectionId: nullishToOptional(z144.string()),
4174
- userId: nullishToOptional(z144.number())
4182
+ connectionId: nullishToOptional(z145.string()),
4183
+ userId: nullishToOptional(z145.number())
4175
4184
  });
4176
- var ExportDestinationsMap = z144.object({
4177
- webhookUrl: z144.string().optional(),
4185
+ var ExportDestinationsMap = z145.object({
4186
+ webhookUrl: z145.string().optional(),
4178
4187
  destinationSnDocs: ExporterDestinationDocs.optional(),
4179
4188
  destinationS3: ExporterDestinationS3.optional(),
4180
4189
  destinationGithub: ExporterDestinationGithub.optional(),
@@ -4182,93 +4191,93 @@ var ExportDestinationsMap = z144.object({
4182
4191
  destinationGitlab: ExporterDestinationGitlab.optional(),
4183
4192
  destinationBitbucket: ExporterDestinationBitbucket.optional()
4184
4193
  });
4185
- var PipelineEventType = z145.enum(["OnVersionReleased", "OnHeadChanged", "OnSourceUpdated", "None"]);
4186
- var PipelineDestinationGitType = z145.enum(["Github", "Gitlab", "Bitbucket", "Azure"]);
4187
- var PipelineDestinationExtraType = z145.enum(["WebhookUrl", "S3", "Documentation"]);
4188
- var PipelineDestinationType = z145.union([PipelineDestinationGitType, PipelineDestinationExtraType]);
4189
- var Pipeline = z145.object({
4190
- id: z145.string(),
4191
- name: z145.string(),
4194
+ var PipelineEventType = z146.enum(["OnVersionReleased", "OnHeadChanged", "OnSourceUpdated", "None"]);
4195
+ var PipelineDestinationGitType = z146.enum(["Github", "Gitlab", "Bitbucket", "Azure"]);
4196
+ var PipelineDestinationExtraType = z146.enum(["WebhookUrl", "S3", "Documentation"]);
4197
+ var PipelineDestinationType = z146.union([PipelineDestinationGitType, PipelineDestinationExtraType]);
4198
+ var Pipeline = z146.object({
4199
+ id: z146.string(),
4200
+ name: z146.string(),
4192
4201
  eventType: PipelineEventType,
4193
- isEnabled: z145.boolean(),
4194
- workspaceId: z145.string(),
4195
- designSystemId: z145.string(),
4196
- exporterId: z145.string(),
4197
- brandPersistentId: z145.string().optional(),
4198
- themePersistentId: z145.string().optional(),
4199
- themePersistentIds: z145.string().array().optional(),
4202
+ isEnabled: z146.boolean(),
4203
+ workspaceId: z146.string(),
4204
+ designSystemId: z146.string(),
4205
+ exporterId: z146.string(),
4206
+ brandPersistentId: z146.string().optional(),
4207
+ themePersistentId: z146.string().optional(),
4208
+ themePersistentIds: z146.string().array().optional(),
4200
4209
  // Destinations
4201
4210
  ...ExportDestinationsMap.shape
4202
4211
  });
4203
- var ExportJobDump = z146.object({
4204
- id: z146.string(),
4205
- createdAt: z146.coerce.date(),
4206
- finishedAt: z146.coerce.date(),
4207
- exportArtefacts: z146.string()
4212
+ var ExportJobDump = z147.object({
4213
+ id: z147.string(),
4214
+ createdAt: z147.coerce.date(),
4215
+ finishedAt: z147.coerce.date(),
4216
+ exportArtefacts: z147.string()
4208
4217
  });
4209
- var CodeIntegrationDump = z146.object({
4218
+ var CodeIntegrationDump = z147.object({
4210
4219
  exporters: Exporter.array(),
4211
4220
  pipelines: Pipeline.array(),
4212
4221
  exportJobs: ExportJobDump.array()
4213
4222
  });
4214
4223
  var DesignSystemVersionRoom = Entity.extend({
4215
- designSystemVersionId: z147.string(),
4216
- liveblocksId: z147.string()
4217
- });
4218
- var DesignSystemVersionRoomInternalSettings = z147.object({
4219
- routingVersion: z147.string(),
4220
- isDraftFeatureAdopted: z147.boolean(),
4221
- isApprovalFeatureEnabled: z147.boolean(),
4222
- approvalRequiredForPublishing: z147.boolean()
4223
- });
4224
- var DesignSystemVersionRoomInitialState = z147.object({
4225
- pages: z147.array(DocumentationPageV2),
4226
- groups: z147.array(ElementGroup),
4227
- pageSnapshots: z147.array(DocumentationPageSnapshot),
4228
- groupSnapshots: z147.array(ElementGroupSnapshot),
4229
- pageApprovals: z147.array(DocumentationPageApproval),
4224
+ designSystemVersionId: z148.string(),
4225
+ liveblocksId: z148.string()
4226
+ });
4227
+ var DesignSystemVersionRoomInternalSettings = z148.object({
4228
+ routingVersion: z148.string(),
4229
+ isDraftFeatureAdopted: z148.boolean(),
4230
+ isApprovalFeatureEnabled: z148.boolean(),
4231
+ approvalRequiredForPublishing: z148.boolean()
4232
+ });
4233
+ var DesignSystemVersionRoomInitialState = z148.object({
4234
+ pages: z148.array(DocumentationPageV2),
4235
+ groups: z148.array(ElementGroup),
4236
+ pageSnapshots: z148.array(DocumentationPageSnapshot),
4237
+ groupSnapshots: z148.array(ElementGroupSnapshot),
4238
+ pageApprovals: z148.array(DocumentationPageApproval),
4230
4239
  internalSettings: DesignSystemVersionRoomInternalSettings
4231
4240
  });
4232
- var DesignSystemVersionRoomUpdate = z147.object({
4233
- pages: z147.array(DocumentationPageV2),
4234
- groups: z147.array(ElementGroup),
4235
- pageIdsToDelete: z147.array(z147.string()),
4236
- groupIdsToDelete: z147.array(z147.string()),
4237
- pageSnapshots: z147.array(DocumentationPageSnapshot),
4238
- groupSnapshots: z147.array(ElementGroupSnapshot),
4239
- pageSnapshotIdsToDelete: z147.array(z147.string()),
4240
- groupSnapshotIdsToDelete: z147.array(z147.string()),
4241
- pageHashesToUpdate: z147.record(z147.string(), z147.string()),
4242
- pageApprovals: z147.array(DocumentationPageApproval),
4243
- pageApprovalIdsToDelete: z147.array(z147.string())
4241
+ var DesignSystemVersionRoomUpdate = z148.object({
4242
+ pages: z148.array(DocumentationPageV2),
4243
+ groups: z148.array(ElementGroup),
4244
+ pageIdsToDelete: z148.array(z148.string()),
4245
+ groupIdsToDelete: z148.array(z148.string()),
4246
+ pageSnapshots: z148.array(DocumentationPageSnapshot),
4247
+ groupSnapshots: z148.array(ElementGroupSnapshot),
4248
+ pageSnapshotIdsToDelete: z148.array(z148.string()),
4249
+ groupSnapshotIdsToDelete: z148.array(z148.string()),
4250
+ pageHashesToUpdate: z148.record(z148.string(), z148.string()),
4251
+ pageApprovals: z148.array(DocumentationPageApproval),
4252
+ pageApprovalIdsToDelete: z148.array(z148.string())
4244
4253
  });
4245
4254
  var DocumentationPageRoom = Entity.extend({
4246
- designSystemVersionId: z148.string(),
4247
- documentationPageId: z148.string(),
4248
- liveblocksId: z148.string(),
4249
- isDirty: z148.boolean()
4255
+ designSystemVersionId: z149.string(),
4256
+ documentationPageId: z149.string(),
4257
+ liveblocksId: z149.string(),
4258
+ isDirty: z149.boolean()
4250
4259
  });
4251
- var DocumentationPageRoomState = z148.object({
4252
- pageItems: z148.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
4260
+ var DocumentationPageRoomState = z149.object({
4261
+ pageItems: z149.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
4253
4262
  itemConfiguration: DocumentationItemConfigurationV2
4254
4263
  });
4255
- var DocumentationPageRoomRoomUpdate = z148.object({
4264
+ var DocumentationPageRoomRoomUpdate = z149.object({
4256
4265
  page: DocumentationPageV2,
4257
4266
  pageParent: ElementGroup
4258
4267
  });
4259
4268
  var DocumentationPageRoomInitialStateUpdate = DocumentationPageRoomRoomUpdate.extend({
4260
- pageItems: z148.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
4261
- blockDefinitions: z148.array(PageBlockDefinition)
4269
+ pageItems: z149.array(PageBlockEditorModelV2.or(PageSectionEditorModelV2)),
4270
+ blockDefinitions: z149.array(PageBlockDefinition)
4262
4271
  });
4263
- var RestoredDocumentationPage = z148.object({
4272
+ var RestoredDocumentationPage = z149.object({
4264
4273
  page: DocumentationPageV2,
4265
4274
  pageParent: ElementGroup,
4266
4275
  pageContent: DocumentationPageContentData,
4267
- contentHash: z148.string(),
4268
- snapshotId: z148.string(),
4269
- roomId: z148.string().optional()
4276
+ contentHash: z149.string(),
4277
+ snapshotId: z149.string(),
4278
+ roomId: z149.string().optional()
4270
4279
  });
4271
- var RestoredDocumentationGroup = z148.object({
4280
+ var RestoredDocumentationGroup = z149.object({
4272
4281
  group: ElementGroup,
4273
4282
  parent: ElementGroup
4274
4283
  });
@@ -4278,28 +4287,28 @@ var RoomTypeEnum = /* @__PURE__ */ ((RoomTypeEnum2) => {
4278
4287
  RoomTypeEnum2["Workspace"] = "workspace";
4279
4288
  return RoomTypeEnum2;
4280
4289
  })(RoomTypeEnum || {});
4281
- var RoomTypeSchema = z149.nativeEnum(RoomTypeEnum);
4290
+ var RoomTypeSchema = z150.nativeEnum(RoomTypeEnum);
4282
4291
  var RoomType = RoomTypeSchema.enum;
4283
4292
  var WorkspaceRoom = Entity.extend({
4284
- workspaceId: z150.string(),
4285
- liveblocksId: z150.string()
4293
+ workspaceId: z151.string(),
4294
+ liveblocksId: z151.string()
4286
4295
  });
4287
- var PublishedDocsDump = z151.object({
4296
+ var PublishedDocsDump = z152.object({
4288
4297
  documentation: PublishedDoc,
4289
4298
  pages: PublishedDocPage.array()
4290
4299
  });
4291
- var DocumentationThreadDump = z152.object({
4300
+ var DocumentationThreadDump = z153.object({
4292
4301
  thread: DocumentationCommentThread,
4293
4302
  comments: DocumentationComment.array()
4294
4303
  });
4295
- var DocumentationPageRoomDump = z152.object({
4304
+ var DocumentationPageRoomDump = z153.object({
4296
4305
  room: DocumentationPageRoom,
4297
4306
  threads: DocumentationThreadDump.array()
4298
4307
  });
4299
- var DesignSystemVersionMultiplayerDump = z152.object({
4308
+ var DesignSystemVersionMultiplayerDump = z153.object({
4300
4309
  documentationPages: DocumentationPageRoomDump.array()
4301
4310
  });
4302
- var DesignSystemVersionDump = z152.object({
4311
+ var DesignSystemVersionDump = z153.object({
4303
4312
  version: DesignSystemVersion,
4304
4313
  brands: Brand.array(),
4305
4314
  elements: DesignElement.array(),
@@ -4312,50 +4321,50 @@ var DesignSystemVersionDump = z152.object({
4312
4321
  publishedDocumentations: PublishedDocsDump.array(),
4313
4322
  assetReferences: AssetReference.array()
4314
4323
  });
4315
- var DesignSystemDump = z153.object({
4324
+ var DesignSystemDump = z154.object({
4316
4325
  designSystem: DesignSystem,
4317
4326
  dataSources: DataSource.array(),
4318
4327
  versions: DesignSystemVersionDump.array(),
4319
4328
  customDomain: CustomDomain.optional(),
4320
4329
  files: Asset.array()
4321
4330
  });
4322
- var IntegrationDesignSystem = z154.object({
4323
- designSystemId: z154.string(),
4324
- brandId: z154.string(),
4325
- title: z154.string().optional(),
4326
- userId: z154.string().optional(),
4327
- date: z154.coerce.date().optional()
4328
- });
4329
- var IntegrationCredentialsType = z154.enum(["OAuth2", "PAT"]);
4330
- var IntegrationCredentialsState = z154.enum(["Active", "Inactive"]);
4331
- var IntegrationCredentialsProfile = z154.object({
4332
- id: nullishToOptional(z154.string()),
4333
- email: nullishToOptional(z154.string()),
4334
- handle: nullishToOptional(z154.string()),
4335
- type: nullishToOptional(z154.string()),
4336
- avatarUrl: nullishToOptional(z154.string()),
4337
- organization: nullishToOptional(z154.string()),
4338
- collection: nullishToOptional(z154.string())
4339
- });
4340
- var IntegrationCredentials = z154.object({
4341
- id: z154.string(),
4331
+ var IntegrationDesignSystem = z155.object({
4332
+ designSystemId: z155.string(),
4333
+ brandId: z155.string(),
4334
+ title: z155.string().optional(),
4335
+ userId: z155.string().optional(),
4336
+ date: z155.coerce.date().optional()
4337
+ });
4338
+ var IntegrationCredentialsType = z155.enum(["OAuth2", "PAT"]);
4339
+ var IntegrationCredentialsState = z155.enum(["Active", "Inactive"]);
4340
+ var IntegrationCredentialsProfile = z155.object({
4341
+ id: nullishToOptional(z155.string()),
4342
+ email: nullishToOptional(z155.string()),
4343
+ handle: nullishToOptional(z155.string()),
4344
+ type: nullishToOptional(z155.string()),
4345
+ avatarUrl: nullishToOptional(z155.string()),
4346
+ organization: nullishToOptional(z155.string()),
4347
+ collection: nullishToOptional(z155.string())
4348
+ });
4349
+ var IntegrationCredentials = z155.object({
4350
+ id: z155.string(),
4342
4351
  type: IntegrationCredentialsType,
4343
- integrationId: z154.string(),
4344
- accessToken: z154.string(),
4345
- userId: z154.string(),
4346
- createdAt: z154.coerce.date(),
4347
- refreshToken: z154.string().optional(),
4348
- tokenName: z154.string().optional(),
4349
- expiresAt: z154.coerce.date().optional(),
4350
- refreshedAt: z154.coerce.date().optional(),
4351
- username: z154.string().optional(),
4352
- appInstallationId: z154.string().optional(),
4352
+ integrationId: z155.string(),
4353
+ accessToken: z155.string(),
4354
+ userId: z155.string(),
4355
+ createdAt: z155.coerce.date(),
4356
+ refreshToken: z155.string().optional(),
4357
+ tokenName: z155.string().optional(),
4358
+ expiresAt: z155.coerce.date().optional(),
4359
+ refreshedAt: z155.coerce.date().optional(),
4360
+ username: z155.string().optional(),
4361
+ appInstallationId: z155.string().optional(),
4353
4362
  profile: IntegrationCredentialsProfile.optional(),
4354
- customUrl: z154.string().optional(),
4363
+ customUrl: z155.string().optional(),
4355
4364
  state: IntegrationCredentialsState,
4356
4365
  user: UserMinified.optional()
4357
4366
  });
4358
- var ExtendedIntegrationType = z154.enum([
4367
+ var ExtendedIntegrationType = z155.enum([
4359
4368
  "Figma",
4360
4369
  "Github",
4361
4370
  "Gitlab",
@@ -4366,26 +4375,26 @@ var ExtendedIntegrationType = z154.enum([
4366
4375
  ]);
4367
4376
  var IntegrationType = ExtendedIntegrationType.exclude(["TokenStudio", "FigmaVariablesPlugin"]);
4368
4377
  var GitIntegrationType = IntegrationType.exclude(["Figma"]);
4369
- var Integration = z154.object({
4370
- id: z154.string(),
4371
- workspaceId: z154.string(),
4378
+ var Integration = z155.object({
4379
+ id: z155.string(),
4380
+ workspaceId: z155.string(),
4372
4381
  type: IntegrationType,
4373
- createdAt: z154.coerce.date(),
4374
- integrationCredentials: z154.array(IntegrationCredentials).optional()
4375
- });
4376
- var IntegrationToken = z154.object({
4377
- access_token: z154.string(),
4378
- refresh_token: z154.string().optional(),
4379
- expires_in: z154.union([z154.number().optional(), z154.string().optional()]),
4380
- token_type: z154.string().optional(),
4381
- token_name: z154.string().optional(),
4382
- token_azure_organization_name: z154.string().optional(),
4382
+ createdAt: z155.coerce.date(),
4383
+ integrationCredentials: z155.array(IntegrationCredentials).optional()
4384
+ });
4385
+ var IntegrationToken = z155.object({
4386
+ access_token: z155.string(),
4387
+ refresh_token: z155.string().optional(),
4388
+ expires_in: z155.union([z155.number().optional(), z155.string().optional()]),
4389
+ token_type: z155.string().optional(),
4390
+ token_name: z155.string().optional(),
4391
+ token_azure_organization_name: z155.string().optional(),
4383
4392
  // Azure Cloud PAT only
4384
- token_azure_collection_name: z154.string().optional(),
4393
+ token_azure_collection_name: z155.string().optional(),
4385
4394
  // Azure Server PAT only
4386
- token_bitbucket_username: z154.string().optional(),
4395
+ token_bitbucket_username: z155.string().optional(),
4387
4396
  // Bitbucket only
4388
- custom_url: z154.string().optional().transform((value) => {
4397
+ custom_url: z155.string().optional().transform((value) => {
4389
4398
  if (!value?.trim())
4390
4399
  return void 0;
4391
4400
  return formatCustomUrl(value);
@@ -4421,98 +4430,98 @@ function formatCustomUrl(url) {
4421
4430
  }
4422
4431
  return forbiddenCustomUrlDomainList.some((domain) => formattedUrl.includes(domain)) ? void 0 : formattedUrl;
4423
4432
  }
4424
- var WorkspaceDump = z155.object({
4433
+ var WorkspaceDump = z156.object({
4425
4434
  workspace: Workspace,
4426
4435
  designSystems: DesignSystemDump.array(),
4427
4436
  codeIntegration: CodeIntegrationDump,
4428
4437
  integrations: Integration.array()
4429
4438
  });
4430
- var UserDump = z156.object({
4439
+ var UserDump = z157.object({
4431
4440
  user: User,
4432
4441
  workspaces: WorkspaceDump.array()
4433
4442
  });
4434
- var NpmProxyToken = z157.object({
4435
- access: z157.string(),
4436
- expiresAt: z157.number()
4443
+ var NpmProxyToken = z158.object({
4444
+ access: z158.string(),
4445
+ expiresAt: z158.number()
4437
4446
  });
4438
- var SessionData = z157.object({
4439
- returnToUrl: z157.string().optional(),
4447
+ var SessionData = z158.object({
4448
+ returnToUrl: z158.string().optional(),
4440
4449
  npmProxyToken: NpmProxyToken.optional()
4441
4450
  });
4442
- var Session = z157.object({
4443
- id: z157.string(),
4444
- expiresAt: z157.coerce.date(),
4445
- userId: z157.string().nullable(),
4451
+ var Session = z158.object({
4452
+ id: z158.string(),
4453
+ expiresAt: z158.coerce.date(),
4454
+ userId: z158.string().nullable(),
4446
4455
  data: SessionData
4447
4456
  });
4448
- var AuthTokens = z157.object({
4449
- access: z157.string(),
4450
- refresh: z157.string()
4457
+ var AuthTokens = z158.object({
4458
+ access: z158.string(),
4459
+ refresh: z158.string()
4451
4460
  });
4452
- var UserSession = z157.object({
4461
+ var UserSession = z158.object({
4453
4462
  session: Session,
4454
4463
  user: User.nullable()
4455
4464
  });
4456
- var DesignSystemInviteEmailRecipient = z158.object({
4457
- email: z158.string(),
4465
+ var DesignSystemInviteEmailRecipient = z159.object({
4466
+ email: z159.string(),
4458
4467
  role: WorkspaceRoleSchema
4459
4468
  });
4460
- var DesignSystemInviteEmailData = z158.object({
4469
+ var DesignSystemInviteEmailData = z159.object({
4461
4470
  workspace: Workspace,
4462
4471
  designSystem: DesignSystem,
4463
4472
  invitedBy: User,
4464
- documentationDomain: z158.string().optional()
4473
+ documentationDomain: z159.string().optional()
4465
4474
  });
4466
- var WorkspaceInviteEmailRecipient = z159.object({
4467
- email: z159.string(),
4475
+ var WorkspaceInviteEmailRecipient = z160.object({
4476
+ email: z160.string(),
4468
4477
  role: WorkspaceRoleSchema
4469
4478
  });
4470
- var WorkspaceInviteEmailData = z159.object({
4479
+ var WorkspaceInviteEmailData = z160.object({
4471
4480
  workspace: Workspace,
4472
4481
  invitedBy: User,
4473
- documentationDomain: z159.string().optional()
4474
- });
4475
- var EventDataSourceImported = z160.object({
4476
- type: z160.literal("DataSourceImported"),
4477
- workspaceId: z160.string(),
4478
- designSystemId: z160.string()
4482
+ documentationDomain: z160.string().optional()
4479
4483
  });
4480
- var EventVersionReleased = z161.object({
4481
- type: z161.literal("DesignSystemVersionReleased"),
4484
+ var EventDataSourceImported = z161.object({
4485
+ type: z161.literal("DataSourceImported"),
4482
4486
  workspaceId: z161.string(),
4483
- designSystemId: z161.string(),
4484
- versionId: z161.string()
4485
- });
4486
- var Event = z162.discriminatedUnion("type", [EventVersionReleased, EventDataSourceImported]);
4487
- var ExportJobDocumentationContext = z163.object({
4488
- isSingleVersionDocs: z163.boolean(),
4489
- versionSlug: z163.string(),
4487
+ designSystemId: z161.string()
4488
+ });
4489
+ var EventVersionReleased = z162.object({
4490
+ type: z162.literal("DesignSystemVersionReleased"),
4491
+ workspaceId: z162.string(),
4492
+ designSystemId: z162.string(),
4493
+ versionId: z162.string()
4494
+ });
4495
+ var Event = z163.discriminatedUnion("type", [EventVersionReleased, EventDataSourceImported]);
4496
+ var ExportJobDocumentationContext = z164.object({
4497
+ isSingleVersionDocs: z164.boolean(),
4498
+ versionSlug: z164.string(),
4490
4499
  environment: PublishedDocEnvironment
4491
4500
  });
4492
- var ExportJobContext = z163.object({
4493
- apiUrl: z163.string(),
4494
- accessToken: z163.string(),
4495
- designSystemId: z163.string(),
4496
- designSystemName: z163.string(),
4497
- exporterId: z163.string(),
4498
- versionId: z163.string(),
4499
- brandId: z163.string().optional(),
4500
- themeId: z163.string().optional(),
4501
- themePersistentIds: z163.string().array().optional(),
4502
- exporterName: z163.string(),
4501
+ var ExportJobContext = z164.object({
4502
+ apiUrl: z164.string(),
4503
+ accessToken: z164.string(),
4504
+ designSystemId: z164.string(),
4505
+ designSystemName: z164.string(),
4506
+ exporterId: z164.string(),
4507
+ versionId: z164.string(),
4508
+ brandId: z164.string().optional(),
4509
+ themeId: z164.string().optional(),
4510
+ themePersistentIds: z164.string().array().optional(),
4511
+ exporterName: z164.string(),
4503
4512
  documentation: ExportJobDocumentationContext.optional()
4504
4513
  });
4505
- var ExportJobExporterConfiguration = z163.object({
4506
- exporterPackageUrl: z163.string(),
4514
+ var ExportJobExporterConfiguration = z164.object({
4515
+ exporterPackageUrl: z164.string(),
4507
4516
  exporterPropertyValues: ExporterPropertyValue.array()
4508
4517
  });
4509
- var ExporterFunctionPayload = z164.object({
4510
- exportJobId: z164.string(),
4511
- exportContextId: z164.string(),
4512
- designSystemId: z164.string(),
4513
- workspaceId: z164.string()
4518
+ var ExporterFunctionPayload = z165.object({
4519
+ exportJobId: z165.string(),
4520
+ exportContextId: z165.string(),
4521
+ designSystemId: z165.string(),
4522
+ workspaceId: z165.string()
4514
4523
  });
4515
- var ExportJobDestinationType = z165.enum([
4524
+ var ExportJobDestinationType = z166.enum([
4516
4525
  "s3",
4517
4526
  "webhookUrl",
4518
4527
  "github",
@@ -4521,30 +4530,30 @@ var ExportJobDestinationType = z165.enum([
4521
4530
  "gitlab",
4522
4531
  "bitbucket"
4523
4532
  ]);
4524
- var ExportJobStatus = z165.enum(["InProgress", "Success", "Failed", "Timeout"]);
4525
- var ExportJobLogEntryType = z165.enum(["success", "info", "warning", "error", "user"]);
4526
- var ExportJobLogEntry = z165.object({
4527
- id: z165.string().optional(),
4528
- time: z165.coerce.date(),
4533
+ var ExportJobStatus = z166.enum(["InProgress", "Success", "Failed", "Timeout"]);
4534
+ var ExportJobLogEntryType = z166.enum(["success", "info", "warning", "error", "user"]);
4535
+ var ExportJobLogEntry = z166.object({
4536
+ id: z166.string().optional(),
4537
+ time: z166.coerce.date(),
4529
4538
  type: ExportJobLogEntryType,
4530
- message: z165.string()
4539
+ message: z166.string()
4531
4540
  });
4532
- var ExportJobPullRequestDestinationResult = z165.object({
4533
- pullRequestUrl: z165.string()
4541
+ var ExportJobPullRequestDestinationResult = z166.object({
4542
+ pullRequestUrl: z166.string()
4534
4543
  });
4535
- var ExportJobS3DestinationResult = z165.object({
4536
- bucket: z165.string(),
4537
- urlPrefix: z165.string().optional(),
4538
- path: z165.string(),
4539
- files: z165.array(z165.string()),
4540
- url: nullishToOptional(z165.string()),
4541
- urls: nullishToOptional(z165.string().array())
4544
+ var ExportJobS3DestinationResult = z166.object({
4545
+ bucket: z166.string(),
4546
+ urlPrefix: z166.string().optional(),
4547
+ path: z166.string(),
4548
+ files: z166.array(z166.string()),
4549
+ url: nullishToOptional(z166.string()),
4550
+ urls: nullishToOptional(z166.string().array())
4542
4551
  });
4543
- var ExportJobDocsDestinationResult = z165.object({
4544
- url: z165.string()
4552
+ var ExportJobDocsDestinationResult = z166.object({
4553
+ url: z166.string()
4545
4554
  });
4546
- var ExportJobResult = z165.object({
4547
- error: z165.string().optional(),
4555
+ var ExportJobResult = z166.object({
4556
+ error: z166.string().optional(),
4548
4557
  s3: nullishToOptional(ExportJobS3DestinationResult),
4549
4558
  github: nullishToOptional(ExportJobPullRequestDestinationResult),
4550
4559
  azure: nullishToOptional(ExportJobPullRequestDestinationResult),
@@ -4553,22 +4562,22 @@ var ExportJobResult = z165.object({
4553
4562
  sndocs: nullishToOptional(ExportJobDocsDestinationResult),
4554
4563
  logs: nullishToOptional(ExportJobLogEntry.array())
4555
4564
  });
4556
- var ExportJob = z165.object({
4557
- id: z165.string(),
4558
- createdAt: z165.coerce.date(),
4559
- finishedAt: z165.coerce.date().optional(),
4560
- designSystemId: z165.string(),
4561
- designSystemVersionId: z165.string(),
4562
- workspaceId: z165.string(),
4563
- scheduleId: z165.string().nullish(),
4564
- exporterId: z165.string(),
4565
- brandId: z165.string().optional(),
4566
- themeId: z165.string().optional(),
4567
- themePersistentIds: z165.string().array().optional(),
4568
- estimatedExecutionTime: z165.number().optional(),
4565
+ var ExportJob = z166.object({
4566
+ id: z166.string(),
4567
+ createdAt: z166.coerce.date(),
4568
+ finishedAt: z166.coerce.date().optional(),
4569
+ designSystemId: z166.string(),
4570
+ designSystemVersionId: z166.string(),
4571
+ workspaceId: z166.string(),
4572
+ scheduleId: z166.string().nullish(),
4573
+ exporterId: z166.string(),
4574
+ brandId: z166.string().optional(),
4575
+ themeId: z166.string().optional(),
4576
+ themePersistentIds: z166.string().array().optional(),
4577
+ estimatedExecutionTime: z166.number().optional(),
4569
4578
  status: ExportJobStatus,
4570
4579
  result: ExportJobResult.optional(),
4571
- createdByUserId: z165.string().optional(),
4580
+ createdByUserId: z166.string().optional(),
4572
4581
  // Destinations
4573
4582
  ...ExportDestinationsMap.shape
4574
4583
  });
@@ -4582,30 +4591,30 @@ var ExportJobFindByFilter = ExportJob.pick({
4582
4591
  themeId: true,
4583
4592
  brandId: true
4584
4593
  }).extend({
4585
- destinations: z165.array(ExportJobDestinationType),
4594
+ destinations: z166.array(ExportJobDestinationType),
4586
4595
  docsEnvironment: PublishedDocEnvironment
4587
4596
  }).partial();
4588
- var ExporterWorkspaceMembershipRole = z166.enum(["Owner", "OwnerArchived", "User"]);
4589
- var ExporterWorkspaceMembership = z167.object({
4590
- id: z167.string(),
4591
- workspaceId: z167.string(),
4592
- exporterId: z167.string(),
4597
+ var ExporterWorkspaceMembershipRole = z167.enum(["Owner", "OwnerArchived", "User"]);
4598
+ var ExporterWorkspaceMembership = z168.object({
4599
+ id: z168.string(),
4600
+ workspaceId: z168.string(),
4601
+ exporterId: z168.string(),
4593
4602
  role: ExporterWorkspaceMembershipRole
4594
4603
  });
4595
- var FlaggedFeature = z168.enum([
4604
+ var FlaggedFeature = z169.enum([
4596
4605
  "FigmaImporterV2",
4597
4606
  "ShadowOpacityOptional",
4598
4607
  "DisableImporter",
4599
4608
  "VariablesOrder",
4600
4609
  "TypographyPropsKeepAliases"
4601
4610
  ]);
4602
- var FeatureFlagMap = z168.record(FlaggedFeature, z168.boolean());
4603
- var FeatureFlag = z168.object({
4604
- id: z168.string(),
4611
+ var FeatureFlagMap = z169.record(FlaggedFeature, z169.boolean());
4612
+ var FeatureFlag = z169.object({
4613
+ id: z169.string(),
4605
4614
  feature: FlaggedFeature,
4606
- createdAt: z168.coerce.date(),
4607
- enabled: z168.boolean(),
4608
- designSystemId: z168.string().optional()
4615
+ createdAt: z169.coerce.date(),
4616
+ enabled: z169.boolean(),
4617
+ designSystemId: z169.string().optional()
4609
4618
  });
4610
4619
  var OAuthProviderNames = /* @__PURE__ */ ((OAuthProviderNames2) => {
4611
4620
  OAuthProviderNames2["Figma"] = "figma";
@@ -4615,108 +4624,108 @@ var OAuthProviderNames = /* @__PURE__ */ ((OAuthProviderNames2) => {
4615
4624
  OAuthProviderNames2["Bitbucket"] = "bitbucket";
4616
4625
  return OAuthProviderNames2;
4617
4626
  })(OAuthProviderNames || {});
4618
- var OAuthProviderSchema = z169.nativeEnum(OAuthProviderNames);
4627
+ var OAuthProviderSchema = z170.nativeEnum(OAuthProviderNames);
4619
4628
  var OAuthProvider = OAuthProviderSchema.enum;
4620
- var ExternalOAuthRequest = z170.object({
4621
- id: z170.string(),
4629
+ var ExternalOAuthRequest = z171.object({
4630
+ id: z171.string(),
4622
4631
  provider: OAuthProviderSchema,
4623
- userId: z170.string(),
4624
- state: z170.string(),
4625
- createdAt: z170.coerce.date()
4632
+ userId: z171.string(),
4633
+ state: z171.string(),
4634
+ createdAt: z171.coerce.date()
4626
4635
  });
4627
- var GitObjectsQuery = z171.object({
4628
- organization: z171.string().optional(),
4636
+ var GitObjectsQuery = z172.object({
4637
+ organization: z172.string().optional(),
4629
4638
  // Azure Organization | Bitbucket Workspace slug | Gitlab Group | Github Account (User or Organization)
4630
- project: z171.string().optional(),
4639
+ project: z172.string().optional(),
4631
4640
  // Only for Bitbucket and Azure
4632
- repository: z171.string().optional(),
4641
+ repository: z172.string().optional(),
4633
4642
  // For all providers. For Gitlab, it's called "project".
4634
- branch: z171.string().optional(),
4643
+ branch: z172.string().optional(),
4635
4644
  // For all providers.
4636
- user: z171.string().optional()
4645
+ user: z172.string().optional()
4637
4646
  // Gitlab user
4638
4647
  });
4639
- var GitOrganization = z171.object({
4640
- id: z171.string(),
4641
- name: z171.string(),
4642
- url: z171.string(),
4643
- slug: z171.string()
4648
+ var GitOrganization = z172.object({
4649
+ id: z172.string(),
4650
+ name: z172.string(),
4651
+ url: z172.string(),
4652
+ slug: z172.string()
4644
4653
  });
4645
- var GitProject = z171.object({
4646
- id: z171.string(),
4647
- name: z171.string(),
4648
- url: z171.string(),
4649
- slug: z171.string()
4654
+ var GitProject = z172.object({
4655
+ id: z172.string(),
4656
+ name: z172.string(),
4657
+ url: z172.string(),
4658
+ slug: z172.string()
4650
4659
  });
4651
- var GitRepository = z171.object({
4652
- id: z171.string(),
4653
- name: z171.string(),
4654
- url: z171.string(),
4655
- slug: z171.string(),
4660
+ var GitRepository = z172.object({
4661
+ id: z172.string(),
4662
+ name: z172.string(),
4663
+ url: z172.string(),
4664
+ slug: z172.string(),
4656
4665
  /**
4657
4666
  * Can be undefined when:
4658
4667
  * - there are no branches in the repository yet
4659
4668
  * - Git provider doesn't expose this information on a repository via their API
4660
4669
  */
4661
- defaultBranch: z171.string().optional()
4670
+ defaultBranch: z172.string().optional()
4662
4671
  });
4663
- var GitBranch = z171.object({
4664
- name: z171.string(),
4665
- lastCommitId: z171.string()
4672
+ var GitBranch = z172.object({
4673
+ name: z172.string(),
4674
+ lastCommitId: z172.string()
4666
4675
  });
4667
- var IntegrationTokenSchemaOld = z172.object({
4668
- id: z172.string(),
4669
- provider: OAuthProviderSchema,
4670
- scope: z172.string(),
4671
- userId: z172.string(),
4672
- accessToken: z172.string(),
4673
- refreshToken: z172.string(),
4674
- expiresAt: z172.coerce.date(),
4675
- externalUserId: z172.string().nullish()
4676
- });
4677
- var WorkspaceOAuthRequestSchema = z173.object({
4676
+ var IntegrationTokenSchemaOld = z173.object({
4678
4677
  id: z173.string(),
4679
- workspaceId: z173.string(),
4680
4678
  provider: OAuthProviderSchema,
4679
+ scope: z173.string(),
4681
4680
  userId: z173.string(),
4682
- createdAt: z173.coerce.date()
4681
+ accessToken: z173.string(),
4682
+ refreshToken: z173.string(),
4683
+ expiresAt: z173.coerce.date(),
4684
+ externalUserId: z173.string().nullish()
4685
+ });
4686
+ var WorkspaceOAuthRequestSchema = z174.object({
4687
+ id: z174.string(),
4688
+ workspaceId: z174.string(),
4689
+ provider: OAuthProviderSchema,
4690
+ userId: z174.string(),
4691
+ createdAt: z174.coerce.date()
4683
4692
  });
4684
- var AnyRecord = z174.record(z174.any());
4693
+ var AnyRecord = z175.record(z175.any());
4685
4694
  var NpmPackageVersionDist = AnyRecord.and(
4686
- z174.object({
4687
- tarball: z174.string()
4695
+ z175.object({
4696
+ tarball: z175.string()
4688
4697
  })
4689
4698
  );
4690
4699
  var NpmPackageVersion = AnyRecord.and(
4691
- z174.object({
4700
+ z175.object({
4692
4701
  dist: NpmPackageVersionDist
4693
4702
  })
4694
4703
  );
4695
4704
  var NpmPackage = AnyRecord.and(
4696
- z174.object({
4697
- _id: z174.string(),
4698
- name: z174.string(),
4705
+ z175.object({
4706
+ _id: z175.string(),
4707
+ name: z175.string(),
4699
4708
  // e.g. "latest": "1.2.3"
4700
- "dist-tags": z174.record(z174.string(), z174.string()),
4709
+ "dist-tags": z175.record(z175.string(), z175.string()),
4701
4710
  // "1.2.3": {...}
4702
- versions: z174.record(NpmPackageVersion)
4711
+ versions: z175.record(NpmPackageVersion)
4703
4712
  })
4704
4713
  );
4705
- var NpmProxyTokenPayload = z175.object({
4706
- npmProxyRegistryConfigId: z175.string()
4707
- });
4708
- var PersonalAccessToken = z176.object({
4709
- id: z176.string(),
4710
- userId: z176.string(),
4711
- workspaceId: z176.string().optional(),
4712
- designSystemId: z176.string().optional(),
4714
+ var NpmProxyTokenPayload = z176.object({
4715
+ npmProxyRegistryConfigId: z176.string()
4716
+ });
4717
+ var PersonalAccessToken = z177.object({
4718
+ id: z177.string(),
4719
+ userId: z177.string(),
4720
+ workspaceId: z177.string().optional(),
4721
+ designSystemId: z177.string().optional(),
4713
4722
  workspaceRole: WorkspaceRoleSchema.optional(),
4714
- name: z176.string(),
4715
- hidden: z176.boolean(),
4716
- token: z176.string(),
4717
- scope: z176.string().optional(),
4718
- createdAt: z176.coerce.date(),
4719
- expireAt: z176.coerce.date().optional()
4723
+ name: z177.string(),
4724
+ hidden: z177.boolean(),
4725
+ token: z177.string(),
4726
+ scope: z177.string().optional(),
4727
+ createdAt: z177.coerce.date(),
4728
+ expireAt: z177.coerce.date().optional()
4720
4729
  });
4721
4730
 
4722
4731
  // src/api/conversion/documentation/documentation-item-configuration-v1-to-dto.ts
@@ -5133,93 +5142,93 @@ function integrationCredentialToDto(credential) {
5133
5142
  }
5134
5143
 
5135
5144
  // src/api/dto/aux/color.ts
5136
- import { z as z177 } from "zod";
5137
- var DTOColorTokenInlineData = z177.object({
5138
- value: z177.string().regex(/^#[a-f0-9]{6,8}$/)
5145
+ import { z as z178 } from "zod";
5146
+ var DTOColorTokenInlineData = z178.object({
5147
+ value: z178.string().regex(/^#[a-f0-9]{6,8}$/)
5139
5148
  });
5140
5149
 
5141
5150
  // src/api/dto/aux/meta.ts
5142
- import { z as z178 } from "zod";
5143
- var DTOObjectMeta = z178.object({
5144
- name: z178.string().max(512),
5145
- description: z178.string().max(2048).optional()
5151
+ import { z as z179 } from "zod";
5152
+ var DTOObjectMeta = z179.object({
5153
+ name: z179.string().max(512),
5154
+ description: z179.string().max(2048).optional()
5146
5155
  });
5147
5156
 
5148
5157
  // src/api/dto/aux/pagination.ts
5149
- import { z as z179 } from "zod";
5150
- var DTOPagination = z179.object({
5151
- limit: z179.string().optional(),
5152
- offset: z179.string().optional()
5158
+ import { z as z180 } from "zod";
5159
+ var DTOPagination = z180.object({
5160
+ limit: z180.string().optional(),
5161
+ offset: z180.string().optional()
5153
5162
  });
5154
5163
 
5155
5164
  // src/api/dto/bff/app-bootstrap-data.ts
5156
- import { z as z213 } from "zod";
5165
+ import { z as z214 } from "zod";
5157
5166
 
5158
5167
  // src/api/dto/design-systems/brand.ts
5159
- import { z as z180 } from "zod";
5160
- var DTOBrand = z180.object({
5161
- id: z180.string(),
5162
- designSystemVersionId: z180.string(),
5163
- persistentId: z180.string(),
5168
+ import { z as z181 } from "zod";
5169
+ var DTOBrand = z181.object({
5170
+ id: z181.string(),
5171
+ designSystemVersionId: z181.string(),
5172
+ persistentId: z181.string(),
5164
5173
  meta: ObjectMeta
5165
5174
  });
5166
- var DTOBrandGetResponse = z180.object({ brand: DTOBrand });
5167
- var DTOBrandCreateResponse = z180.object({
5175
+ var DTOBrandGetResponse = z181.object({ brand: DTOBrand });
5176
+ var DTOBrandCreateResponse = z181.object({
5168
5177
  brand: DTOBrand
5169
5178
  });
5170
- var DTOBrandsListResponse = z180.object({ brands: z180.array(DTOBrand) });
5171
- var DTOBrandCreatePayload = z180.object({
5172
- persistentId: z180.string().uuid(),
5179
+ var DTOBrandsListResponse = z181.object({ brands: z181.array(DTOBrand) });
5180
+ var DTOBrandCreatePayload = z181.object({
5181
+ persistentId: z181.string().uuid(),
5173
5182
  meta: DTOObjectMeta
5174
5183
  });
5175
- var DTOBrandUpdatePayload = z180.object({
5184
+ var DTOBrandUpdatePayload = z181.object({
5176
5185
  meta: DTOObjectMeta.optional(),
5177
- persistentId: z180.string()
5186
+ persistentId: z181.string()
5178
5187
  });
5179
5188
 
5180
5189
  // src/api/dto/design-systems/component.ts
5181
- import { z as z181 } from "zod";
5182
- var DTODesignSystemComponent = z181.object({
5183
- id: z181.string(),
5184
- persistentId: z181.string(),
5185
- designSystemVersionId: z181.string(),
5186
- brandId: z181.string(),
5190
+ import { z as z182 } from "zod";
5191
+ var DTODesignSystemComponent = z182.object({
5192
+ id: z182.string(),
5193
+ persistentId: z182.string(),
5194
+ designSystemVersionId: z182.string(),
5195
+ brandId: z182.string(),
5187
5196
  meta: DTOObjectMeta,
5188
- createdAt: z181.coerce.date(),
5189
- updatedAt: z181.coerce.date()
5197
+ createdAt: z182.coerce.date(),
5198
+ updatedAt: z182.coerce.date()
5190
5199
  });
5191
- var DTODesignSystemComponentResponse = z181.object({
5200
+ var DTODesignSystemComponentResponse = z182.object({
5192
5201
  designSystemComponent: DTODesignSystemComponent
5193
5202
  });
5194
- var DTODesignSystemComponentListResponse = z181.object({
5203
+ var DTODesignSystemComponentListResponse = z182.object({
5195
5204
  designSystemComponents: DTODesignSystemComponent.array()
5196
5205
  });
5197
- var DTODesignSystemComponentCreateInput = z181.object({
5198
- brandId: z181.string(),
5206
+ var DTODesignSystemComponentCreateInput = z182.object({
5207
+ brandId: z182.string(),
5199
5208
  // Persistent ID,
5200
- persistentId: z181.string(),
5209
+ persistentId: z182.string(),
5201
5210
  meta: DTOObjectMeta
5202
5211
  });
5203
5212
 
5204
5213
  // src/api/dto/design-systems/contact.ts
5205
- import { z as z185 } from "zod";
5214
+ import { z as z186 } from "zod";
5206
5215
 
5207
5216
  // src/api/dto/users/authenticated-user.ts
5208
- import { z as z183 } from "zod";
5217
+ import { z as z184 } from "zod";
5209
5218
 
5210
5219
  // src/api/dto/users/user.ts
5211
- import { z as z182 } from "zod";
5212
- var DTOUserProfile = z182.object({
5213
- name: z182.string(),
5214
- nickname: z182.string().optional(),
5215
- avatar: z182.string().optional()
5216
- });
5217
- var DTOUser = z182.object({
5218
- id: z182.string(),
5219
- email: z182.string(),
5220
+ import { z as z183 } from "zod";
5221
+ var DTOUserProfile = z183.object({
5222
+ name: z183.string(),
5223
+ nickname: z183.string().optional(),
5224
+ avatar: z183.string().optional()
5225
+ });
5226
+ var DTOUser = z183.object({
5227
+ id: z183.string(),
5228
+ email: z183.string(),
5220
5229
  profile: DTOUserProfile
5221
5230
  });
5222
- var DTOUserGetResponse = z182.object({
5231
+ var DTOUserGetResponse = z183.object({
5223
5232
  user: DTOUser
5224
5233
  });
5225
5234
  var DTOUserProfileUpdate = UserProfileUpdate;
@@ -5228,156 +5237,156 @@ var DTOUserProfileUpdate = UserProfileUpdate;
5228
5237
  var DTOUserOnboardingDepartment = UserOnboardingDepartment;
5229
5238
  var DTOUserOnboardingJobLevel = UserOnboardingJobLevel;
5230
5239
  var DTOUserSource = UserSource;
5231
- var DTOUserOnboarding = z183.object({
5232
- companyName: z183.string().optional(),
5233
- numberOfPeopleInOrg: z183.string().optional(),
5234
- numberOfPeopleInDesignTeam: z183.string().optional(),
5240
+ var DTOUserOnboarding = z184.object({
5241
+ companyName: z184.string().optional(),
5242
+ numberOfPeopleInOrg: z184.string().optional(),
5243
+ numberOfPeopleInDesignTeam: z184.string().optional(),
5235
5244
  department: DTOUserOnboardingDepartment.optional(),
5236
- jobTitle: z183.string().optional(),
5237
- phase: z183.string().optional(),
5245
+ jobTitle: z184.string().optional(),
5246
+ phase: z184.string().optional(),
5238
5247
  jobLevel: DTOUserOnboardingJobLevel.optional(),
5239
- designSystemName: z183.string().optional(),
5240
- defaultDestination: z183.string().optional(),
5241
- isPageDraftOnboardingFinished: z183.boolean().optional()
5248
+ designSystemName: z184.string().optional(),
5249
+ defaultDestination: z184.string().optional(),
5250
+ isPageDraftOnboardingFinished: z184.boolean().optional()
5242
5251
  });
5243
5252
  var DTOAuthenticatedUserProfile = DTOUserProfile.extend({
5244
5253
  onboarding: DTOUserOnboarding.optional()
5245
5254
  });
5246
5255
  var DTOAuthenticatedUser = DTOUser.extend({
5247
5256
  profile: DTOAuthenticatedUserProfile,
5248
- createdAt: z183.coerce.date(),
5249
- loggedOutAt: z183.coerce.date().optional(),
5257
+ createdAt: z184.coerce.date(),
5258
+ loggedOutAt: z184.coerce.date().optional(),
5250
5259
  source: DTOUserSource.optional()
5251
5260
  });
5252
- var DTOAuthenticatedUserResponse = z183.object({
5261
+ var DTOAuthenticatedUserResponse = z184.object({
5253
5262
  user: DTOAuthenticatedUser
5254
5263
  });
5255
5264
 
5256
5265
  // src/api/dto/users/update.ts
5257
- import { z as z184 } from "zod";
5258
- var DTOUserProfileUpdateResponse = z184.object({
5266
+ import { z as z185 } from "zod";
5267
+ var DTOUserProfileUpdateResponse = z185.object({
5259
5268
  user: User
5260
5269
  });
5261
5270
 
5262
5271
  // src/api/dto/design-systems/contact.ts
5263
- var DTODesignSystemContactsResponse = z185.object({
5264
- contacts: z185.object({
5265
- workspace: z185.array(DTOUser),
5266
- designSystem: z185.array(DTOUser)
5272
+ var DTODesignSystemContactsResponse = z186.object({
5273
+ contacts: z186.object({
5274
+ workspace: z186.array(DTOUser),
5275
+ designSystem: z186.array(DTOUser)
5267
5276
  })
5268
5277
  });
5269
5278
 
5270
5279
  // src/api/dto/design-systems/data-source.ts
5271
- import { z as z186 } from "zod";
5280
+ import { z as z187 } from "zod";
5272
5281
  var DTODataSourceFigmaScope = DataSourceFigmaScope;
5273
- var DTODataSourceFigmaFileVersion = z186.object({
5274
- id: z186.string(),
5275
- created_at: z186.coerce.date(),
5276
- label: z186.string(),
5277
- description: z186.string()
5278
- });
5279
- var DTODataSourceFigmaCloud = z186.object({
5280
- fileId: z186.string(),
5282
+ var DTODataSourceFigmaFileVersion = z187.object({
5283
+ id: z187.string(),
5284
+ created_at: z187.coerce.date(),
5285
+ label: z187.string(),
5286
+ description: z187.string()
5287
+ });
5288
+ var DTODataSourceFigmaCloud = z187.object({
5289
+ fileId: z187.string(),
5281
5290
  state: DataSourceFigmaState,
5282
5291
  autoImportMode: DataSourceAutoImportMode,
5283
- fileThumbnailUrl: z186.string().optional(),
5292
+ fileThumbnailUrl: z187.string().optional(),
5284
5293
  lastImportResult: SourceImportSummary.nullish(),
5285
- lastImportedAt: z186.coerce.date().nullish(),
5294
+ lastImportedAt: z187.coerce.date().nullish(),
5286
5295
  lastImportedVersion: DTODataSourceFigmaFileVersion.nullish(),
5287
- lastUpdatesCheckedAt: z186.date().nullish(),
5288
- ownerId: z186.string(),
5289
- ownerUserName: z186.string().optional(),
5290
- preferredCredentialId: z186.string().optional(),
5296
+ lastUpdatesCheckedAt: z187.date().nullish(),
5297
+ ownerId: z187.string(),
5298
+ ownerUserName: z187.string().optional(),
5299
+ preferredCredentialId: z187.string().optional(),
5291
5300
  stats: DataSourceStats
5292
5301
  });
5293
- var DTODataSourceFigma = z186.object({
5294
- id: z186.string(),
5295
- type: z186.literal(DataSourceRemoteType.Enum.Figma),
5296
- fileName: z186.string(),
5302
+ var DTODataSourceFigma = z187.object({
5303
+ id: z187.string(),
5304
+ type: z187.literal(DataSourceRemoteType.Enum.Figma),
5305
+ fileName: z187.string(),
5297
5306
  scope: DTODataSourceFigmaScope,
5298
- brandId: z186.string(),
5299
- themeId: z186.string().nullish(),
5307
+ brandId: z187.string(),
5308
+ themeId: z187.string().nullish(),
5300
5309
  cloud: DTODataSourceFigmaCloud.nullish()
5301
5310
  });
5302
- var DTODataSourceTokenStudio = z186.object({
5303
- id: z186.string(),
5304
- type: z186.literal(DataSourceRemoteType.Enum.TokenStudio),
5305
- fileName: z186.string(),
5306
- brandId: z186.string(),
5307
- themeId: z186.string().nullish(),
5308
- tokenStudio: z186.object({
5309
- settings: z186.object({
5310
- dryRun: z186.boolean(),
5311
- verbose: z186.boolean(),
5312
- preciseCopy: z186.boolean()
5311
+ var DTODataSourceTokenStudio = z187.object({
5312
+ id: z187.string(),
5313
+ type: z187.literal(DataSourceRemoteType.Enum.TokenStudio),
5314
+ fileName: z187.string(),
5315
+ brandId: z187.string(),
5316
+ themeId: z187.string().nullish(),
5317
+ tokenStudio: z187.object({
5318
+ settings: z187.object({
5319
+ dryRun: z187.boolean(),
5320
+ verbose: z187.boolean(),
5321
+ preciseCopy: z187.boolean()
5313
5322
  }),
5314
- connectionName: z186.string(),
5315
- lastImportedAt: z186.coerce.date(),
5316
- lastImportedResults: z186.array(
5317
- z186.object({
5318
- mapping: z186.object({
5319
- tokenSets: z186.array(z186.string()),
5320
- supernovaBrand: z186.string(),
5321
- supernovaTheme: z186.string().optional()
5323
+ connectionName: z187.string(),
5324
+ lastImportedAt: z187.coerce.date(),
5325
+ lastImportedResults: z187.array(
5326
+ z187.object({
5327
+ mapping: z187.object({
5328
+ tokenSets: z187.array(z187.string()),
5329
+ supernovaBrand: z187.string(),
5330
+ supernovaTheme: z187.string().optional()
5322
5331
  }),
5323
- isFailed: z186.boolean(),
5324
- tokensCreated: z186.number(),
5325
- tokensDeleted: z186.number(),
5326
- tokensUpdated: z186.number()
5332
+ isFailed: z187.boolean(),
5333
+ tokensCreated: z187.number(),
5334
+ tokensDeleted: z187.number(),
5335
+ tokensUpdated: z187.number()
5327
5336
  })
5328
5337
  )
5329
5338
  })
5330
5339
  });
5331
- var DTODataSourceFigmaVariablesPlugin = z186.object({
5332
- id: z186.string(),
5333
- type: z186.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
5334
- fileName: z186.string(),
5335
- brandId: z186.string(),
5336
- upload: z186.object({
5337
- remoteId: z186.string(),
5340
+ var DTODataSourceFigmaVariablesPlugin = z187.object({
5341
+ id: z187.string(),
5342
+ type: z187.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
5343
+ fileName: z187.string(),
5344
+ brandId: z187.string(),
5345
+ upload: z187.object({
5346
+ remoteId: z187.string(),
5338
5347
  remoteSourceType: DataSourceUploadRemoteSource,
5339
- lastImportedAt: z186.coerce.date().optional(),
5348
+ lastImportedAt: z187.coerce.date().optional(),
5340
5349
  lastImportMetadata: DataSourceUploadImportMetadata.optional(),
5341
- isTokenTypeSplitEnabled: z186.boolean()
5350
+ isTokenTypeSplitEnabled: z187.boolean()
5342
5351
  }),
5343
- figmaVariablesPlugin: z186.object({
5344
- fileId: z186.string(),
5345
- lastImportedAt: z186.coerce.date().optional(),
5352
+ figmaVariablesPlugin: z187.object({
5353
+ fileId: z187.string(),
5354
+ lastImportedAt: z187.coerce.date().optional(),
5346
5355
  lastImportMetadata: DataSourceUploadImportMetadata.optional(),
5347
- isTokenTypeSplitEnabled: z186.boolean(),
5348
- isCollectionsMigrationCompleted: z186.boolean().default(false)
5356
+ isTokenTypeSplitEnabled: z187.boolean(),
5357
+ isCollectionsMigrationCompleted: z187.boolean().default(false)
5349
5358
  })
5350
5359
  });
5351
- var DTODataSource = z186.discriminatedUnion("type", [
5360
+ var DTODataSource = z187.discriminatedUnion("type", [
5352
5361
  DTODataSourceFigma,
5353
5362
  DTODataSourceFigmaVariablesPlugin,
5354
5363
  DTODataSourceTokenStudio
5355
5364
  ]);
5356
- var DTODataSourcesListResponse = z186.object({
5357
- sources: z186.array(DTODataSource)
5365
+ var DTODataSourcesListResponse = z187.object({
5366
+ sources: z187.array(DTODataSource)
5358
5367
  });
5359
- var DTODataSourceResponse = z186.object({
5368
+ var DTODataSourceResponse = z187.object({
5360
5369
  source: DTODataSource
5361
5370
  });
5362
- var DTODataSourceFigmaCreatePayload = z186.object({
5363
- brandPersistentId: z186.string(),
5364
- figmaFileUrl: z186.string(),
5371
+ var DTODataSourceFigmaCreatePayload = z187.object({
5372
+ brandPersistentId: z187.string(),
5373
+ figmaFileUrl: z187.string(),
5365
5374
  scope: DTODataSourceFigmaScope,
5366
5375
  autoImportMode: DataSourceAutoImportMode
5367
5376
  });
5368
- var DTODataSourceFigmaImportPayload = z186.object({
5369
- sourceIds: z186.array(z186.string())
5377
+ var DTODataSourceFigmaImportPayload = z187.object({
5378
+ sourceIds: z187.array(z187.string())
5370
5379
  });
5371
5380
 
5372
5381
  // src/api/dto/design-systems/design-system.ts
5373
- import { z as z189 } from "zod";
5382
+ import { z as z190 } from "zod";
5374
5383
 
5375
5384
  // src/api/dto/design-systems/members.ts
5376
- import { z as z188 } from "zod";
5385
+ import { z as z189 } from "zod";
5377
5386
 
5378
5387
  // src/api/dto/design-systems/role.ts
5379
- import { z as z187 } from "zod";
5380
- var DTODesignSystemRole = z187.enum([
5388
+ import { z as z188 } from "zod";
5389
+ var DTODesignSystemRole = z188.enum([
5381
5390
  WorkspaceRole.Admin,
5382
5391
  WorkspaceRole.Contributor,
5383
5392
  WorkspaceRole.Creator,
@@ -5385,29 +5394,29 @@ var DTODesignSystemRole = z187.enum([
5385
5394
  ]);
5386
5395
 
5387
5396
  // src/api/dto/design-systems/members.ts
5388
- var DTODesignSystemMember = z188.object({
5389
- userId: z188.string(),
5397
+ var DTODesignSystemMember = z189.object({
5398
+ userId: z189.string(),
5390
5399
  /**
5391
5400
  * Role that the member has in the design system,
5392
5401
  * undefined if set to inherit from workspace
5393
5402
  */
5394
5403
  designSystemRole: DTODesignSystemRole.optional()
5395
5404
  });
5396
- var DTODesignSystemInvitation = z188.object({
5397
- id: z188.string(),
5398
- workspaceInvitationId: z188.string(),
5405
+ var DTODesignSystemInvitation = z189.object({
5406
+ id: z189.string(),
5407
+ workspaceInvitationId: z189.string(),
5399
5408
  /**
5400
5409
  * Role that the invitation has in the design system,
5401
5410
  * undefined if set to inherit from workspace
5402
5411
  */
5403
5412
  designSystemRole: DTODesignSystemRole.optional()
5404
5413
  });
5405
- var DTODesignSystemMemberListResponse = z188.object({
5414
+ var DTODesignSystemMemberListResponse = z189.object({
5406
5415
  members: DTODesignSystemMember.array(),
5407
5416
  invitations: DTODesignSystemInvitation.array()
5408
5417
  });
5409
- var DTODesignSystemMembersUpdateResponse = z188.object({
5410
- ok: z188.literal(true)
5418
+ var DTODesignSystemMembersUpdateResponse = z189.object({
5419
+ ok: z189.literal(true)
5411
5420
  });
5412
5421
  var DTODesignSystemMembersUpdatePayload = DesignSystemMembershipUpdates;
5413
5422
 
@@ -5418,14 +5427,14 @@ var DTODesignSystem = DesignSystem.omit({
5418
5427
  docExporterId: true
5419
5428
  }).extend({
5420
5429
  meta: ObjectMeta,
5421
- docExporterId: z189.string(),
5422
- sources: z189.array(z189.any()),
5423
- isPublic: z189.literal(true),
5430
+ docExporterId: z190.string(),
5431
+ sources: z190.array(z190.any()),
5432
+ isPublic: z190.literal(true),
5424
5433
  /**
5425
5434
  * Whether or not user who is requesting the design system
5426
5435
  * has access to the design system's contents.
5427
5436
  */
5428
- isAvailableToUser: z189.boolean(),
5437
+ isAvailableToUser: z190.boolean(),
5429
5438
  /**
5430
5439
  * @deprecated
5431
5440
  */
@@ -5436,17 +5445,17 @@ var DTODesignSystem = DesignSystem.omit({
5436
5445
  */
5437
5446
  effectiveRole: DTODesignSystemRole.optional()
5438
5447
  });
5439
- var DTODesignSystemResponse = z189.object({
5448
+ var DTODesignSystemResponse = z190.object({
5440
5449
  designSystem: DTODesignSystem
5441
5450
  });
5442
- var DTODesignSystemsListResponse = z189.object({
5451
+ var DTODesignSystemsListResponse = z190.object({
5443
5452
  designSystems: DTODesignSystem.array()
5444
5453
  });
5445
- var DTODesignSystemCreateInput = z189.object({
5446
- workspaceId: z189.string(),
5454
+ var DTODesignSystemCreateInput = z190.object({
5455
+ workspaceId: z190.string(),
5447
5456
  meta: ObjectMeta.optional(),
5448
- name: z189.string().min(2).max(64).optional(),
5449
- description: z189.string().max(1024).optional(),
5457
+ name: z190.string().min(2).max(64).optional(),
5458
+ description: z190.string().max(1024).optional(),
5450
5459
  accessMode: DesignSystemAccessMode.optional(),
5451
5460
  invites: DTODesignSystemMembersUpdatePayload.pick({
5452
5461
  usersToInvite: true,
@@ -5456,20 +5465,20 @@ var DTODesignSystemCreateInput = z189.object({
5456
5465
  });
5457
5466
 
5458
5467
  // src/api/dto/design-systems/elements-diff.ts
5459
- import { z as z190 } from "zod";
5460
- var DTODiffCountBase = z190.object({
5461
- created: z190.number(),
5462
- updated: z190.number(),
5463
- deleted: z190.number()
5468
+ import { z as z191 } from "zod";
5469
+ var DTODiffCountBase = z191.object({
5470
+ created: z191.number(),
5471
+ updated: z191.number(),
5472
+ deleted: z191.number()
5464
5473
  });
5465
- var DTODesignElementsDataDiffResponse = z190.object({
5474
+ var DTODesignElementsDataDiffResponse = z191.object({
5466
5475
  tokens: DTODiffCountBase,
5467
5476
  assets: DTODiffCountBase
5468
5477
  });
5469
5478
 
5470
5479
  // src/api/dto/design-systems/figma-variables.ts
5471
- import { z as z191 } from "zod";
5472
- var DimensionsVariableScopeSchema = z191.enum([
5480
+ import { z as z192 } from "zod";
5481
+ var DimensionsVariableScopeSchema = z192.enum([
5473
5482
  "CORNER_RADIUS",
5474
5483
  "WIDTH_HEIGHT",
5475
5484
  "GAP",
@@ -5483,120 +5492,120 @@ var DimensionsVariableScopeSchema = z191.enum([
5483
5492
  "PARAGRAPH_INDENT",
5484
5493
  "FONT_WEIGHT"
5485
5494
  ]);
5486
- var StringVariableScopeSchema = z191.enum(["TEXT_CONTENT", "FONT_FAMILY", "FONT_STYLE"]);
5495
+ var StringVariableScopeSchema = z192.enum(["TEXT_CONTENT", "FONT_FAMILY", "FONT_STYLE"]);
5487
5496
  var DimensionsVariableScopeType = DimensionsVariableScopeSchema.enum;
5488
5497
  var StringVariableScopeType = StringVariableScopeSchema.enum;
5489
- var VariableScope = z191.string();
5490
- var ReferencedVariableOrigin = z191.object({
5491
- name: z191.string(),
5492
- remote: z191.boolean()
5498
+ var VariableScope = z192.string();
5499
+ var ReferencedVariableOrigin = z192.object({
5500
+ name: z192.string(),
5501
+ remote: z192.boolean()
5493
5502
  });
5494
- var RGB = z191.object({
5495
- r: z191.number(),
5496
- g: z191.number(),
5497
- b: z191.number()
5503
+ var RGB = z192.object({
5504
+ r: z192.number(),
5505
+ g: z192.number(),
5506
+ b: z192.number()
5498
5507
  });
5499
5508
  var RGBA = RGB.extend({
5500
- a: z191.number()
5501
- });
5502
- var VariableAlias = z191.object({
5503
- type: z191.literal("VARIABLE_ALIAS"),
5504
- id: z191.string(),
5505
- resolvedValue: z191.boolean().or(z191.number()).or(z191.string()).or(RGBA).or(RGB).optional(),
5506
- referenceOrigin: ReferencedVariableOrigin.optional().or(z191.null())
5507
- });
5508
- var VariableValue = z191.boolean().or(z191.number()).or(z191.string()).or(RGBA).or(RGB).or(VariableAlias);
5509
- var ResolvedVariableType = z191.enum(["BOOLEAN", "FLOAT", "STRING", "COLOR"]);
5510
- var Variable = z191.object({
5511
- id: z191.string(),
5512
- name: z191.string(),
5513
- key: z191.string(),
5514
- variableCollectionId: z191.string(),
5509
+ a: z192.number()
5510
+ });
5511
+ var VariableAlias = z192.object({
5512
+ type: z192.literal("VARIABLE_ALIAS"),
5513
+ id: z192.string(),
5514
+ resolvedValue: z192.boolean().or(z192.number()).or(z192.string()).or(RGBA).or(RGB).optional(),
5515
+ referenceOrigin: ReferencedVariableOrigin.optional().or(z192.null())
5516
+ });
5517
+ var VariableValue = z192.boolean().or(z192.number()).or(z192.string()).or(RGBA).or(RGB).or(VariableAlias);
5518
+ var ResolvedVariableType = z192.enum(["BOOLEAN", "FLOAT", "STRING", "COLOR"]);
5519
+ var Variable = z192.object({
5520
+ id: z192.string(),
5521
+ name: z192.string(),
5522
+ key: z192.string(),
5523
+ variableCollectionId: z192.string(),
5515
5524
  resolvedType: ResolvedVariableType,
5516
- valuesByMode: z191.record(VariableValue),
5517
- remote: z191.boolean(),
5518
- description: z191.string(),
5519
- hiddenFromPublishing: z191.boolean(),
5520
- scopes: z191.array(VariableScope),
5521
- codeSyntax: z191.record(z191.any()).optional()
5522
- });
5523
- var VariableMode = z191.object({
5524
- modeId: z191.string(),
5525
- name: z191.string()
5526
- });
5527
- var Collection2 = z191.object({
5528
- id: z191.string(),
5529
- name: z191.string(),
5530
- modes: z191.array(VariableMode),
5531
- defaultModeId: z191.string(),
5532
- remote: z191.boolean(),
5533
- hiddenFromPublishing: z191.boolean()
5534
- });
5535
- var VariablesMapping = z191.object({
5536
- variableCollections: z191.array(z191.string()).min(1),
5537
- variableMode: z191.string().min(1),
5538
- supernovaBrand: z191.string().min(1),
5539
- supernovaTheme: z191.string().min(1).optional().or(z191.null())
5540
- });
5541
- var FormattedCollections = z191.object({
5542
- variables: z191.record(z191.string(), Variable),
5543
- variableCollections: z191.record(z191.string(), Collection2),
5544
- mappings: z191.array(VariablesMapping).optional(),
5545
- variablesOrder: z191.string().array().optional()
5525
+ valuesByMode: z192.record(VariableValue),
5526
+ remote: z192.boolean(),
5527
+ description: z192.string(),
5528
+ hiddenFromPublishing: z192.boolean(),
5529
+ scopes: z192.array(VariableScope),
5530
+ codeSyntax: z192.record(z192.any()).optional()
5531
+ });
5532
+ var VariableMode = z192.object({
5533
+ modeId: z192.string(),
5534
+ name: z192.string()
5535
+ });
5536
+ var Collection2 = z192.object({
5537
+ id: z192.string(),
5538
+ name: z192.string(),
5539
+ modes: z192.array(VariableMode),
5540
+ defaultModeId: z192.string(),
5541
+ remote: z192.boolean(),
5542
+ hiddenFromPublishing: z192.boolean()
5543
+ });
5544
+ var VariablesMapping = z192.object({
5545
+ variableCollections: z192.array(z192.string()).min(1),
5546
+ variableMode: z192.string().min(1),
5547
+ supernovaBrand: z192.string().min(1),
5548
+ supernovaTheme: z192.string().min(1).optional().or(z192.null())
5549
+ });
5550
+ var FormattedCollections = z192.object({
5551
+ variables: z192.record(z192.string(), Variable),
5552
+ variableCollections: z192.record(z192.string(), Collection2),
5553
+ mappings: z192.array(VariablesMapping).optional(),
5554
+ variablesOrder: z192.string().array().optional()
5546
5555
  });
5547
5556
 
5548
5557
  // src/api/dto/design-systems/import-job.ts
5549
- import { z as z192 } from "zod";
5550
- var DTOImportJob = z192.object({
5551
- id: z192.string(),
5552
- designSystemId: z192.string(),
5553
- designSystemVersionId: z192.string(),
5554
- operation: z192.literal("Import"),
5555
- createdAt: z192.coerce.date(),
5556
- stateChangedAt: z192.coerce.date(),
5558
+ import { z as z193 } from "zod";
5559
+ var DTOImportJob = z193.object({
5560
+ id: z193.string(),
5561
+ designSystemId: z193.string(),
5562
+ designSystemVersionId: z193.string(),
5563
+ operation: z193.literal("Import"),
5564
+ createdAt: z193.coerce.date(),
5565
+ stateChangedAt: z193.coerce.date(),
5557
5566
  state: ImportJobState,
5558
- sourceIds: z192.string().array()
5567
+ sourceIds: z193.string().array()
5559
5568
  });
5560
- var DTOImportJobResponse = z192.object({
5569
+ var DTOImportJobResponse = z193.object({
5561
5570
  job: DTOImportJob
5562
5571
  });
5563
- var DTOBffFigmaImportRequestBody = z192.object({
5564
- type: z192.literal(DataSourceRemoteType.Enum.Figma),
5565
- brandPersistentId: z192.string().optional(),
5566
- fileId: z192.string(),
5572
+ var DTOBffFigmaImportRequestBody = z193.object({
5573
+ type: z193.literal(DataSourceRemoteType.Enum.Figma),
5574
+ brandPersistentId: z193.string().optional(),
5575
+ fileId: z193.string(),
5567
5576
  scope: DataSourceFigmaScope,
5568
5577
  autoImportMode: DataSourceAutoImportMode
5569
5578
  });
5570
- var DTOBffUploadImportRequestBody = z192.object({
5571
- type: z192.enum([DataSourceRemoteType.Enum.FigmaVariablesPlugin, "Upload"]).transform((v) => DataSourceRemoteType.Enum.FigmaVariablesPlugin),
5572
- brandPersistentId: z192.string().optional(),
5573
- sourceName: z192.string().optional(),
5574
- remoteId: z192.string(),
5575
- isTokenTypeSplitEnabled: z192.boolean().optional(),
5576
- payload: z192.any()
5579
+ var DTOBffUploadImportRequestBody = z193.object({
5580
+ type: z193.enum([DataSourceRemoteType.Enum.FigmaVariablesPlugin, "Upload"]).transform((v) => DataSourceRemoteType.Enum.FigmaVariablesPlugin),
5581
+ brandPersistentId: z193.string().optional(),
5582
+ sourceName: z193.string().optional(),
5583
+ remoteId: z193.string(),
5584
+ isTokenTypeSplitEnabled: z193.boolean().optional(),
5585
+ payload: z193.any()
5577
5586
  });
5578
- var DTOBffImportRequestBody = z192.discriminatedUnion("type", [
5587
+ var DTOBffImportRequestBody = z193.discriminatedUnion("type", [
5579
5588
  DTOBffFigmaImportRequestBody,
5580
5589
  DTOBffUploadImportRequestBody
5581
5590
  ]);
5582
5591
 
5583
5592
  // src/api/dto/design-systems/stats.ts
5584
- import { z as z193 } from "zod";
5585
- var DTODesignSystemVersionStats = z193.object({
5586
- tokens: z193.number(),
5587
- designSystemComponents: z193.number(),
5588
- assets: z193.number(),
5589
- documentationPages: z193.number()
5593
+ import { z as z194 } from "zod";
5594
+ var DTODesignSystemVersionStats = z194.object({
5595
+ tokens: z194.number(),
5596
+ designSystemComponents: z194.number(),
5597
+ assets: z194.number(),
5598
+ documentationPages: z194.number()
5590
5599
  });
5591
- var DTODesignSystemVersionStatsQuery = z193.object({
5592
- brandId: z193.string().optional()
5600
+ var DTODesignSystemVersionStatsQuery = z194.object({
5601
+ brandId: z194.string().optional()
5593
5602
  });
5594
5603
 
5595
5604
  // src/api/dto/design-systems/version.ts
5596
- import { z as z205 } from "zod";
5605
+ import { z as z206 } from "zod";
5597
5606
 
5598
5607
  // src/api/payloads/design-systems/update-design-system.ts
5599
- import { z as z194 } from "zod";
5608
+ import { z as z195 } from "zod";
5600
5609
  var DTODesignSystemUpdateInput = DesignSystem.partial().omit({
5601
5610
  id: true,
5602
5611
  workspaceId: true,
@@ -5608,40 +5617,40 @@ var DTODesignSystemUpdateInput = DesignSystem.partial().omit({
5608
5617
  }).extend({
5609
5618
  meta: ObjectMeta.partial().optional()
5610
5619
  });
5611
- var DTODesignSystemUpdateAccessModeInput = z194.object({
5620
+ var DTODesignSystemUpdateAccessModeInput = z195.object({
5612
5621
  accessMode: DesignSystemAccessMode,
5613
- retain: z194.object({
5614
- userIds: z194.string().array(),
5615
- inviteIds: z194.string().array()
5622
+ retain: z195.object({
5623
+ userIds: z195.string().array(),
5624
+ inviteIds: z195.string().array()
5616
5625
  }).optional()
5617
5626
  });
5618
5627
 
5619
5628
  // src/api/payloads/design-systems/version.ts
5620
- import { z as z195 } from "zod";
5621
- var ObjectMeta2 = z195.object({
5622
- name: z195.string().max(150).optional(),
5623
- description: z195.string().max(2e3).optional()
5629
+ import { z as z196 } from "zod";
5630
+ var ObjectMeta2 = z196.object({
5631
+ name: z196.string().max(150).optional(),
5632
+ description: z196.string().max(2e3).optional()
5624
5633
  });
5625
5634
  function validateDesignSystemVersion(version) {
5626
5635
  const urlCompliantRegex = /^[a-zA-Z0-9+.-]+$/;
5627
5636
  return urlCompliantRegex.test(version);
5628
5637
  }
5629
- var DTOCreateVersionInput = z195.object({
5638
+ var DTOCreateVersionInput = z196.object({
5630
5639
  meta: ObjectMeta2,
5631
- version: z195.string().refine(validateDesignSystemVersion, {
5640
+ version: z196.string().refine(validateDesignSystemVersion, {
5632
5641
  message: "Invalid semantic versioning format"
5633
5642
  }),
5634
- changeLog: z195.string().optional()
5643
+ changeLog: z196.string().optional()
5635
5644
  });
5636
- var DTOUpdateVersionInput = z195.object({
5645
+ var DTOUpdateVersionInput = z196.object({
5637
5646
  meta: ObjectMeta2,
5638
- version: z195.string(),
5647
+ version: z196.string(),
5639
5648
  // required for PUT, but not editable
5640
- changeLog: z195.string()
5649
+ changeLog: z196.string()
5641
5650
  });
5642
5651
 
5643
5652
  // src/api/payloads/documentation/block-definitions.ts
5644
- import { z as z196 } from "zod";
5653
+ import { z as z197 } from "zod";
5645
5654
 
5646
5655
  // src/api/dto/documentation/block-definition.ts
5647
5656
  var DTOPageBlockDefinitionBehavior = PageBlockDefinitionBehavior;
@@ -5653,63 +5662,63 @@ var DTOPageBlockColorV2 = PageBlockColorV2;
5653
5662
  var DTOPageBlockDefinition = PageBlockDefinition;
5654
5663
 
5655
5664
  // src/api/payloads/documentation/block-definitions.ts
5656
- var DTOGetBlockDefinitionsOutput = z196.object({
5657
- definitions: z196.array(DTOPageBlockDefinition)
5665
+ var DTOGetBlockDefinitionsOutput = z197.object({
5666
+ definitions: z197.array(DTOPageBlockDefinition)
5658
5667
  });
5659
5668
 
5660
5669
  // src/api/payloads/documentation/design-data-doc-diff.ts
5661
- import { z as z197 } from "zod";
5662
- var DTODocumentationPublishTypeQueryParams = z197.object({
5663
- environment: z197.enum(["Live", "Preview"])
5670
+ import { z as z198 } from "zod";
5671
+ var DTODocumentationPublishTypeQueryParams = z198.object({
5672
+ environment: z198.enum(["Live", "Preview"])
5664
5673
  });
5665
5674
 
5666
5675
  // src/api/payloads/export/pipeline.ts
5667
- import { z as z199 } from "zod";
5676
+ import { z as z200 } from "zod";
5668
5677
 
5669
5678
  // src/api/dto/export/exporter-property.ts
5670
- import { z as z198 } from "zod";
5671
- var PrimitiveValue = z198.number().or(z198.boolean()).or(z198.string());
5672
- var ArrayValue = z198.array(z198.string());
5673
- var ObjectValue = z198.record(z198.string());
5679
+ import { z as z199 } from "zod";
5680
+ var PrimitiveValue = z199.number().or(z199.boolean()).or(z199.string());
5681
+ var ArrayValue = z199.array(z199.string());
5682
+ var ObjectValue = z199.record(z199.string());
5674
5683
  var DTOExporterPropertyDefinitionValue = PrimitiveValue.or(ArrayValue).or(ObjectValue);
5675
- var DTOExporterPropertyType = z198.enum(["Enum", "Boolean", "String", "Number", "Array", "Object"]);
5676
- var PropertyDefinitionBase = z198.object({
5677
- key: z198.string(),
5678
- title: z198.string(),
5679
- description: z198.string()
5684
+ var DTOExporterPropertyType = z199.enum(["Enum", "Boolean", "String", "Number", "Array", "Object"]);
5685
+ var PropertyDefinitionBase = z199.object({
5686
+ key: z199.string(),
5687
+ title: z199.string(),
5688
+ description: z199.string()
5680
5689
  });
5681
5690
  var DTOExporterPropertyDefinitionEnum = PropertyDefinitionBase.extend({
5682
- type: z198.literal(DTOExporterPropertyType.Enum.Enum),
5683
- options: z198.string().array(),
5684
- default: z198.string()
5691
+ type: z199.literal(DTOExporterPropertyType.Enum.Enum),
5692
+ options: z199.string().array(),
5693
+ default: z199.string()
5685
5694
  });
5686
5695
  var DTOExporterPropertyDefinitionBoolean = PropertyDefinitionBase.extend({
5687
- type: z198.literal(DTOExporterPropertyType.Enum.Boolean),
5688
- default: z198.boolean()
5696
+ type: z199.literal(DTOExporterPropertyType.Enum.Boolean),
5697
+ default: z199.boolean()
5689
5698
  });
5690
5699
  var DTOExporterPropertyDefinitionString = PropertyDefinitionBase.extend({
5691
- type: z198.literal(DTOExporterPropertyType.Enum.String),
5692
- default: z198.string()
5700
+ type: z199.literal(DTOExporterPropertyType.Enum.String),
5701
+ default: z199.string()
5693
5702
  });
5694
5703
  var DTOExporterPropertyDefinitionNumber = PropertyDefinitionBase.extend({
5695
- type: z198.literal(DTOExporterPropertyType.Enum.Number),
5696
- default: z198.number()
5704
+ type: z199.literal(DTOExporterPropertyType.Enum.Number),
5705
+ default: z199.number()
5697
5706
  });
5698
5707
  var DTOExporterPropertyDefinitionArray = PropertyDefinitionBase.extend({
5699
- type: z198.literal(DTOExporterPropertyType.Enum.Array),
5708
+ type: z199.literal(DTOExporterPropertyType.Enum.Array),
5700
5709
  default: ArrayValue
5701
5710
  });
5702
5711
  var DTOExporterPropertyDefinitionObject = PropertyDefinitionBase.extend({
5703
- type: z198.literal(DTOExporterPropertyType.Enum.Object),
5712
+ type: z199.literal(DTOExporterPropertyType.Enum.Object),
5704
5713
  default: ObjectValue,
5705
- allowedKeys: z198.object({
5706
- options: z198.string().array()
5714
+ allowedKeys: z199.object({
5715
+ options: z199.string().array()
5707
5716
  }).optional(),
5708
- allowedValues: z198.object({
5709
- options: z198.string().array()
5717
+ allowedValues: z199.object({
5718
+ options: z199.string().array()
5710
5719
  }).optional()
5711
5720
  });
5712
- var DTOExporterPropertyDefinition = z198.discriminatedUnion("type", [
5721
+ var DTOExporterPropertyDefinition = z199.discriminatedUnion("type", [
5713
5722
  DTOExporterPropertyDefinitionEnum,
5714
5723
  DTOExporterPropertyDefinitionBoolean,
5715
5724
  DTOExporterPropertyDefinitionString,
@@ -5717,55 +5726,55 @@ var DTOExporterPropertyDefinition = z198.discriminatedUnion("type", [
5717
5726
  DTOExporterPropertyDefinitionArray,
5718
5727
  DTOExporterPropertyDefinitionObject
5719
5728
  ]);
5720
- var DTOExporterPropertyDefinitionsResponse = z198.object({
5729
+ var DTOExporterPropertyDefinitionsResponse = z199.object({
5721
5730
  properties: DTOExporterPropertyDefinition.array()
5722
5731
  });
5723
- var DTOExporterPropertyDefinitionValueMap = z198.record(DTOExporterPropertyDefinitionValue);
5732
+ var DTOExporterPropertyDefinitionValueMap = z199.record(DTOExporterPropertyDefinitionValue);
5724
5733
 
5725
5734
  // src/api/payloads/export/pipeline.ts
5726
- var DTOPipelineCreateBody = z199.object({
5727
- name: z199.string(),
5728
- exporterId: z199.string(),
5729
- designSystemId: z199.string(),
5730
- isEnabled: z199.boolean(),
5735
+ var DTOPipelineCreateBody = z200.object({
5736
+ name: z200.string(),
5737
+ exporterId: z200.string(),
5738
+ designSystemId: z200.string(),
5739
+ isEnabled: z200.boolean(),
5731
5740
  eventType: PipelineEventType,
5732
- brandPersistentId: z199.string().optional(),
5733
- themePersistentId: z199.string().optional(),
5734
- themePersistentIds: z199.string().array().optional(),
5741
+ brandPersistentId: z200.string().optional(),
5742
+ themePersistentId: z200.string().optional(),
5743
+ themePersistentIds: z200.string().array().optional(),
5735
5744
  exporterConfiguration: DTOExporterPropertyDefinitionValueMap.optional(),
5736
5745
  destination: PipelineDestinationType.optional(),
5737
5746
  gitQuery: GitObjectsQuery,
5738
- destinations: z199.object({
5747
+ destinations: z200.object({
5739
5748
  s3: ExporterDestinationS3.nullish(),
5740
5749
  azure: ExporterDestinationAzure.nullish(),
5741
5750
  bitbucket: ExporterDestinationBitbucket.nullish(),
5742
5751
  github: ExporterDestinationGithub.nullish(),
5743
5752
  gitlab: ExporterDestinationGitlab.nullish(),
5744
5753
  documentation: ExporterDestinationDocs.nullish(),
5745
- webhookUrl: z199.string().nullish()
5754
+ webhookUrl: z200.string().nullish()
5746
5755
  })
5747
5756
  });
5748
5757
  var DTOPipelineUpdateBody = DTOPipelineCreateBody.extend({
5749
- id: z199.string()
5758
+ id: z200.string()
5750
5759
  });
5751
- var DTOPipelineTriggerBody = z199.object({
5752
- designSystemVersionId: z199.string()
5760
+ var DTOPipelineTriggerBody = z200.object({
5761
+ designSystemVersionId: z200.string()
5753
5762
  });
5754
5763
 
5755
5764
  // src/api/payloads/liveblocks/auth.ts
5756
- import { z as z200 } from "zod";
5757
- var DTOLiveblocksAuthRequest = z200.object({
5758
- room: z200.string().optional()
5765
+ import { z as z201 } from "zod";
5766
+ var DTOLiveblocksAuthRequest = z201.object({
5767
+ room: z201.string().optional()
5759
5768
  });
5760
5769
 
5761
5770
  // src/api/payloads/users/notifications/notification-settings.ts
5762
- import { z as z201 } from "zod";
5763
- var DTOUpdateUserNotificationSettingsPayload = z201.object({
5771
+ import { z as z202 } from "zod";
5772
+ var DTOUpdateUserNotificationSettingsPayload = z202.object({
5764
5773
  notificationSettings: UserNotificationSettings
5765
5774
  });
5766
- var DTOUserNotificationSettingsResponse = z201.object({
5767
- userId: z201.string(),
5768
- workspaceId: z201.string(),
5775
+ var DTOUserNotificationSettingsResponse = z202.object({
5776
+ userId: z202.string(),
5777
+ workspaceId: z202.string(),
5769
5778
  notificationSettings: UserNotificationSettings
5770
5779
  });
5771
5780
 
@@ -5773,13 +5782,13 @@ var DTOUserNotificationSettingsResponse = z201.object({
5773
5782
  var DTOUserProfileUpdatePayload = UserProfileUpdate;
5774
5783
 
5775
5784
  // src/api/payloads/workspaces/transfer-ownership.ts
5776
- import { z as z202 } from "zod";
5777
- var DTOTransferOwnershipPayload = z202.object({
5778
- newOwnerId: z202.string()
5785
+ import { z as z203 } from "zod";
5786
+ var DTOTransferOwnershipPayload = z203.object({
5787
+ newOwnerId: z203.string()
5779
5788
  });
5780
5789
 
5781
5790
  // src/api/payloads/workspaces/workspace-configuration.ts
5782
- import { z as z203 } from "zod";
5791
+ import { z as z204 } from "zod";
5783
5792
  var prohibitedSsoKeys = ["providerId", "metadataXml", "emailDomains"];
5784
5793
  function validateSsoPayload(ssoPayload) {
5785
5794
  const keys = [];
@@ -5802,21 +5811,21 @@ function validateSsoPayload(ssoPayload) {
5802
5811
  keys
5803
5812
  };
5804
5813
  }
5805
- var NpmRegistryInput = z203.object({
5806
- enabledScopes: z203.array(z203.string()),
5807
- customRegistryUrl: z203.string().optional(),
5808
- bypassProxy: z203.boolean().optional(),
5809
- npmProxyRegistryConfigId: z203.string().optional(),
5810
- npmProxyVersion: z203.number().optional(),
5811
- registryType: z203.string(),
5812
- authType: z203.string(),
5813
- authHeaderName: z203.string(),
5814
- authHeaderValue: z203.string(),
5815
- accessToken: z203.string(),
5816
- username: z203.string(),
5817
- password: z203.string()
5818
- });
5819
- var WorkspaceConfigurationPayload = z203.object({
5814
+ var NpmRegistryInput = z204.object({
5815
+ enabledScopes: z204.array(z204.string()),
5816
+ customRegistryUrl: z204.string().optional(),
5817
+ bypassProxy: z204.boolean().optional(),
5818
+ npmProxyRegistryConfigId: z204.string().optional(),
5819
+ npmProxyVersion: z204.number().optional(),
5820
+ registryType: z204.string(),
5821
+ authType: z204.string(),
5822
+ authHeaderName: z204.string(),
5823
+ authHeaderValue: z204.string(),
5824
+ accessToken: z204.string(),
5825
+ username: z204.string(),
5826
+ password: z204.string()
5827
+ });
5828
+ var WorkspaceConfigurationPayload = z204.object({
5820
5829
  ipWhitelist: WorkspaceIpSettings.partial().optional(),
5821
5830
  sso: SsoProvider.partial().optional(),
5822
5831
  npmRegistrySettings: NpmRegistryInput.partial().optional(),
@@ -5824,218 +5833,218 @@ var WorkspaceConfigurationPayload = z203.object({
5824
5833
  });
5825
5834
 
5826
5835
  // src/api/payloads/workspaces/workspace-integrations.ts
5827
- import { z as z204 } from "zod";
5828
- var DTOWorkspaceIntegrationOauthInput = z204.object({
5836
+ import { z as z205 } from "zod";
5837
+ var DTOWorkspaceIntegrationOauthInput = z205.object({
5829
5838
  type: IntegrationType
5830
5839
  });
5831
- var DTOWorkspaceIntegrationPATInput = z204.object({
5832
- userId: z204.string(),
5840
+ var DTOWorkspaceIntegrationPATInput = z205.object({
5841
+ userId: z205.string(),
5833
5842
  type: IntegrationType,
5834
5843
  token: IntegrationToken
5835
5844
  });
5836
- var DTOWorkspaceIntegrationGetGitObjectsInput = z204.object({
5837
- organization: z204.string().optional(),
5845
+ var DTOWorkspaceIntegrationGetGitObjectsInput = z205.object({
5846
+ organization: z205.string().optional(),
5838
5847
  // Azure Organization | Bitbucket Workspace slug | Gitlab Group and Sub-Groups | Github Account (User or Organization)
5839
- project: z204.string().optional(),
5848
+ project: z205.string().optional(),
5840
5849
  // Only for Bitbucket and Azure
5841
- repository: z204.string().optional(),
5850
+ repository: z205.string().optional(),
5842
5851
  // For all providers. Pay attention for Gitlab, they call repositories "projects".
5843
- branch: z204.string().optional(),
5852
+ branch: z205.string().optional(),
5844
5853
  // For all providers, useful for PR creations.
5845
- user: z204.string().optional()
5854
+ user: z205.string().optional()
5846
5855
  // Only for Gitlab User Repositories
5847
5856
  });
5848
5857
 
5849
5858
  // src/api/dto/design-systems/version.ts
5850
- var DTODesignSystemVersion = z205.object({
5851
- id: z205.string(),
5852
- createdAt: z205.coerce.date(),
5859
+ var DTODesignSystemVersion = z206.object({
5860
+ id: z206.string(),
5861
+ createdAt: z206.coerce.date(),
5853
5862
  meta: ObjectMeta,
5854
- version: z205.string(),
5855
- isReadonly: z205.boolean(),
5856
- changeLog: z205.string(),
5857
- designSystemId: z205.string()
5863
+ version: z206.string(),
5864
+ isReadonly: z206.boolean(),
5865
+ changeLog: z206.string(),
5866
+ designSystemId: z206.string()
5858
5867
  });
5859
- var DTODesignSystemVersionsListResponse = z205.object({
5860
- designSystemVersions: z205.array(DTODesignSystemVersion)
5868
+ var DTODesignSystemVersionsListResponse = z206.object({
5869
+ designSystemVersions: z206.array(DTODesignSystemVersion)
5861
5870
  });
5862
- var DTODesignSystemVersionGetResponse = z205.object({
5871
+ var DTODesignSystemVersionGetResponse = z206.object({
5863
5872
  designSystemVersion: DTODesignSystemVersion
5864
5873
  });
5865
- var DTODesignSystemVersionCreationResponse = z205.object({
5874
+ var DTODesignSystemVersionCreationResponse = z206.object({
5866
5875
  meta: ObjectMeta,
5867
- version: z205.string(),
5868
- changeLog: z205.string(),
5869
- isReadOnly: z205.boolean(),
5870
- designSystemId: z205.string(),
5871
- jobId: z205.string()
5872
- });
5873
- var VersionSQSPayload = z205.object({
5874
- jobId: z205.string(),
5875
- designSystemId: z205.string(),
5876
+ version: z206.string(),
5877
+ changeLog: z206.string(),
5878
+ isReadOnly: z206.boolean(),
5879
+ designSystemId: z206.string(),
5880
+ jobId: z206.string()
5881
+ });
5882
+ var VersionSQSPayload = z206.object({
5883
+ jobId: z206.string(),
5884
+ designSystemId: z206.string(),
5876
5885
  input: DTOCreateVersionInput
5877
5886
  });
5878
- var DTODesignSystemVersionJobsResponse = z205.object({
5879
- jobs: z205.array(VersionCreationJob)
5887
+ var DTODesignSystemVersionJobsResponse = z206.object({
5888
+ jobs: z206.array(VersionCreationJob)
5880
5889
  });
5881
- var DTODesignSystemVersionJobStatusResponse = z205.object({
5890
+ var DTODesignSystemVersionJobStatusResponse = z206.object({
5882
5891
  job: VersionCreationJob
5883
5892
  });
5884
5893
 
5885
5894
  // src/api/dto/design-systems/view.ts
5886
- import { z as z206 } from "zod";
5887
- var DTOElementViewColumnSharedAttributes = z206.object({
5888
- id: z206.string(),
5889
- persistentId: z206.string(),
5890
- width: z206.number()
5895
+ import { z as z207 } from "zod";
5896
+ var DTOElementViewColumnSharedAttributes = z207.object({
5897
+ id: z207.string(),
5898
+ persistentId: z207.string(),
5899
+ width: z207.number()
5891
5900
  });
5892
5901
  var DTOElementViewBasePropertyColumn = DTOElementViewColumnSharedAttributes.extend({
5893
- type: z206.literal("BaseProperty"),
5902
+ type: z207.literal("BaseProperty"),
5894
5903
  basePropertyType: ElementViewBaseColumnType
5895
5904
  });
5896
5905
  var DTOElementViewPropertyDefinitionColumn = DTOElementViewColumnSharedAttributes.extend({
5897
- type: z206.literal("PropertyDefinition"),
5898
- propertyDefinitionId: z206.string()
5906
+ type: z207.literal("PropertyDefinition"),
5907
+ propertyDefinitionId: z207.string()
5899
5908
  });
5900
5909
  var DTOElementViewThemeColumn = DTOElementViewColumnSharedAttributes.extend({
5901
- type: z206.literal("Theme"),
5902
- themeId: z206.string()
5910
+ type: z207.literal("Theme"),
5911
+ themeId: z207.string()
5903
5912
  });
5904
- var DTOElementViewColumn = z206.discriminatedUnion("type", [
5913
+ var DTOElementViewColumn = z207.discriminatedUnion("type", [
5905
5914
  DTOElementViewBasePropertyColumn,
5906
5915
  DTOElementViewPropertyDefinitionColumn,
5907
5916
  DTOElementViewThemeColumn
5908
5917
  ]);
5909
- var DTOElementView = z206.object({
5918
+ var DTOElementView = z207.object({
5910
5919
  meta: ObjectMeta,
5911
- persistentId: z206.string(),
5920
+ persistentId: z207.string(),
5912
5921
  targetElementType: ElementPropertyTargetType,
5913
- id: z206.string(),
5914
- isDefault: z206.boolean(),
5915
- columns: z206.array(DTOElementViewColumn)
5922
+ id: z207.string(),
5923
+ isDefault: z207.boolean(),
5924
+ columns: z207.array(DTOElementViewColumn)
5916
5925
  });
5917
- var DTOElementViewsListResponse = z206.object({
5918
- elementDataViews: z206.array(DTOElementView)
5926
+ var DTOElementViewsListResponse = z207.object({
5927
+ elementDataViews: z207.array(DTOElementView)
5919
5928
  });
5920
5929
 
5921
5930
  // src/api/dto/workspaces/git.ts
5922
- import { z as z207 } from "zod";
5923
- var DTOGitOrganization = z207.object({
5924
- id: z207.string(),
5925
- name: z207.string(),
5926
- url: z207.string(),
5927
- slug: z207.string()
5931
+ import { z as z208 } from "zod";
5932
+ var DTOGitOrganization = z208.object({
5933
+ id: z208.string(),
5934
+ name: z208.string(),
5935
+ url: z208.string(),
5936
+ slug: z208.string()
5928
5937
  });
5929
- var DTOGitProject = z207.object({
5930
- id: z207.string(),
5931
- name: z207.string(),
5932
- url: z207.string(),
5933
- slug: z207.string()
5938
+ var DTOGitProject = z208.object({
5939
+ id: z208.string(),
5940
+ name: z208.string(),
5941
+ url: z208.string(),
5942
+ slug: z208.string()
5934
5943
  });
5935
- var DTOGitRepository = z207.object({
5936
- id: z207.string(),
5937
- name: z207.string(),
5938
- url: z207.string(),
5939
- slug: z207.string(),
5940
- defaultBranch: z207.string().optional()
5944
+ var DTOGitRepository = z208.object({
5945
+ id: z208.string(),
5946
+ name: z208.string(),
5947
+ url: z208.string(),
5948
+ slug: z208.string(),
5949
+ defaultBranch: z208.string().optional()
5941
5950
  });
5942
- var DTOGitBranch = z207.object({
5943
- name: z207.string(),
5944
- lastCommitId: z207.string()
5951
+ var DTOGitBranch = z208.object({
5952
+ name: z208.string(),
5953
+ lastCommitId: z208.string()
5945
5954
  });
5946
5955
 
5947
5956
  // src/api/dto/workspaces/integrations.ts
5948
- import { z as z208 } from "zod";
5957
+ import { z as z209 } from "zod";
5949
5958
  var DTOIntegrationCredentials = IntegrationCredentials.omit({
5950
5959
  accessToken: true,
5951
5960
  refreshToken: true
5952
5961
  });
5953
- var DTOIntegration = z208.object({
5954
- id: z208.string(),
5955
- workspaceId: z208.string(),
5962
+ var DTOIntegration = z209.object({
5963
+ id: z209.string(),
5964
+ workspaceId: z209.string(),
5956
5965
  type: ExtendedIntegrationType,
5957
- createdAt: z208.coerce.date(),
5958
- integrationCredentials: z208.array(DTOIntegrationCredentials).optional(),
5959
- integrationDesignSystems: z208.array(IntegrationDesignSystem).optional()
5966
+ createdAt: z209.coerce.date(),
5967
+ integrationCredentials: z209.array(DTOIntegrationCredentials).optional(),
5968
+ integrationDesignSystems: z209.array(IntegrationDesignSystem).optional()
5960
5969
  });
5961
- var DTOIntegrationOAuthGetResponse = z208.object({
5962
- url: z208.string()
5970
+ var DTOIntegrationOAuthGetResponse = z209.object({
5971
+ url: z209.string()
5963
5972
  });
5964
- var DTOIntegrationPostResponse = z208.object({
5973
+ var DTOIntegrationPostResponse = z209.object({
5965
5974
  integration: DTOIntegration
5966
5975
  });
5967
- var DTOIntegrationsGetListResponse = z208.object({
5976
+ var DTOIntegrationsGetListResponse = z209.object({
5968
5977
  integrations: DTOIntegration.array()
5969
5978
  });
5970
5979
 
5971
5980
  // src/api/dto/workspaces/invitations.ts
5972
- import { z as z209 } from "zod";
5973
- var DTOWorkspaceInvitationInput = z209.object({
5974
- email: z209.string().email(),
5981
+ import { z as z210 } from "zod";
5982
+ var DTOWorkspaceInvitationInput = z210.object({
5983
+ email: z210.string().email(),
5975
5984
  role: WorkspaceRoleSchema
5976
5985
  });
5977
- var DTOWorkspaceInvitationsListInput = z209.object({
5986
+ var DTOWorkspaceInvitationsListInput = z210.object({
5978
5987
  invites: DTOWorkspaceInvitationInput.array().max(100),
5979
- designSystemId: z209.string().optional()
5988
+ designSystemId: z210.string().optional()
5980
5989
  });
5981
- var DTOWorkspaceInvitationsResponse = z209.object({
5990
+ var DTOWorkspaceInvitationsResponse = z210.object({
5982
5991
  invitations: WorkspaceInvitation.array()
5983
5992
  });
5984
- var DTOWorkspaceInviteUpdate = z209.object({
5993
+ var DTOWorkspaceInviteUpdate = z210.object({
5985
5994
  role: WorkspaceRoleSchema
5986
5995
  });
5987
- var DTOWorkspaceInvitationUpdateResponse = z209.object({
5996
+ var DTOWorkspaceInvitationUpdateResponse = z210.object({
5988
5997
  invitation: WorkspaceInvitation
5989
5998
  });
5990
5999
 
5991
6000
  // src/api/dto/workspaces/membership.ts
5992
- import { z as z212 } from "zod";
6001
+ import { z as z213 } from "zod";
5993
6002
 
5994
6003
  // src/api/dto/workspaces/workspace.ts
5995
- import { z as z211 } from "zod";
6004
+ import { z as z212 } from "zod";
5996
6005
 
5997
6006
  // src/api/dto/workspaces/npm-registry.ts
5998
- import { z as z210 } from "zod";
6007
+ import { z as z211 } from "zod";
5999
6008
  var DTONpmRegistryConfigConstants = {
6000
6009
  passwordPlaceholder: "redacted"
6001
6010
  };
6002
- var DTONpmRegistryConfig = z210.object({
6011
+ var DTONpmRegistryConfig = z211.object({
6003
6012
  // Registry basic configuration
6004
6013
  registryType: NpmRegistryType,
6005
- registryUrl: z210.string(),
6006
- customRegistryUrl: z210.string().optional(),
6014
+ registryUrl: z211.string(),
6015
+ customRegistryUrl: z211.string().optional(),
6007
6016
  // URL of Supernova NPM packages proxy
6008
- proxyUrl: z210.string(),
6017
+ proxyUrl: z211.string(),
6009
6018
  // Auth configuration
6010
6019
  authType: NpmRegistryAuthType,
6011
- accessToken: z210.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
6012
- username: z210.string().optional(),
6013
- password: z210.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
6020
+ accessToken: z211.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
6021
+ username: z211.string().optional(),
6022
+ password: z211.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
6014
6023
  // NPM package scopes for whih the proxy should be enabled
6015
- enabledScopes: z210.array(z210.string()),
6024
+ enabledScopes: z211.array(z211.string()),
6016
6025
  // True if client should bypass Supernova proxy and connect directly to the registry
6017
6026
  // (e.g. when the NPM registry is behind a VPN or firewall which prevents Supernova from accessing it)
6018
- bypassProxy: z210.boolean()
6027
+ bypassProxy: z211.boolean()
6019
6028
  });
6020
6029
 
6021
6030
  // src/api/dto/workspaces/workspace.ts
6022
6031
  var DTOWorkspaceProfile = WorkspaceProfile;
6023
- var DTOWorkspace = z211.object({
6024
- id: z211.string(),
6032
+ var DTOWorkspace = z212.object({
6033
+ id: z212.string(),
6025
6034
  profile: DTOWorkspaceProfile,
6026
6035
  subscription: Subscription,
6027
6036
  npmRegistry: DTONpmRegistryConfig.optional()
6028
6037
  });
6029
- var DTOWorkspaceCreateInput = z211.object({
6030
- name: z211.string()
6038
+ var DTOWorkspaceCreateInput = z212.object({
6039
+ name: z212.string()
6031
6040
  });
6032
- var DTOWorkspaceResponse = z211.object({
6041
+ var DTOWorkspaceResponse = z212.object({
6033
6042
  workspace: DTOWorkspace
6034
6043
  });
6035
6044
 
6036
6045
  // src/api/dto/workspaces/membership.ts
6037
- var DTOWorkspaceRole = z212.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Contributor"]);
6038
- var DTOUserWorkspaceMembership = z212.object({
6046
+ var DTOWorkspaceRole = z213.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Contributor"]);
6047
+ var DTOUserWorkspaceMembership = z213.object({
6039
6048
  // Workspace the user is a member of
6040
6049
  workspace: DTOWorkspace,
6041
6050
  // Assigned role the user has in the workspace
@@ -6045,26 +6054,26 @@ var DTOUserWorkspaceMembership = z212.object({
6045
6054
  // when a workspace's subscription is downgraded to free tier
6046
6055
  effectiveRole: DTOWorkspaceRole
6047
6056
  });
6048
- var DTOWorkspaceMember = z212.object({
6057
+ var DTOWorkspaceMember = z213.object({
6049
6058
  user: User,
6050
6059
  role: WorkspaceRoleSchema,
6051
6060
  effectiveRole: WorkspaceRoleSchema
6052
6061
  });
6053
- var DTOUserWorkspaceMembershipsResponse = z212.object({
6054
- membership: z212.array(DTOUserWorkspaceMembership)
6062
+ var DTOUserWorkspaceMembershipsResponse = z213.object({
6063
+ membership: z213.array(DTOUserWorkspaceMembership)
6055
6064
  });
6056
- var DTOWorkspaceMembersListResponse = z212.object({
6057
- members: z212.array(DTOWorkspaceMember)
6065
+ var DTOWorkspaceMembersListResponse = z213.object({
6066
+ members: z213.array(DTOWorkspaceMember)
6058
6067
  });
6059
6068
 
6060
6069
  // src/api/dto/bff/app-bootstrap-data.ts
6061
- var DTOAppBootstrapDataQuery = z213.object({
6062
- preferredWorkspaceId: z213.string().optional(),
6063
- preferredDesignSystemId: z213.string().optional(),
6064
- preferredVersionId: z213.string().optional(),
6065
- preferredBrandId: z213.string().optional()
6070
+ var DTOAppBootstrapDataQuery = z214.object({
6071
+ preferredWorkspaceId: z214.string().optional(),
6072
+ preferredDesignSystemId: z214.string().optional(),
6073
+ preferredVersionId: z214.string().optional(),
6074
+ preferredBrandId: z214.string().optional()
6066
6075
  });
6067
- var DTOAppBootstrapDataResponse = z213.object({
6076
+ var DTOAppBootstrapDataResponse = z214.object({
6068
6077
  workspaceMembership: DTOUserWorkspaceMembership.optional(),
6069
6078
  designSystem: DTODesignSystem.optional(),
6070
6079
  version: DTODesignSystemVersion.optional(),
@@ -6072,88 +6081,88 @@ var DTOAppBootstrapDataResponse = z213.object({
6072
6081
  });
6073
6082
 
6074
6083
  // src/api/dto/collections/token-collection.ts
6075
- import { z as z214 } from "zod";
6076
- var DTOTokenCollection = z214.object({
6077
- id: z214.string(),
6078
- persistentId: z214.string(),
6079
- designSystemVersionId: z214.string(),
6084
+ import { z as z215 } from "zod";
6085
+ var DTOTokenCollection = z215.object({
6086
+ id: z215.string(),
6087
+ persistentId: z215.string(),
6088
+ designSystemVersionId: z215.string(),
6080
6089
  meta: ObjectMeta,
6081
6090
  backgroundColor: ColorTokenInlineData.optional(),
6082
- elementPropertyOptionId: z214.string(),
6083
- createdAt: z214.coerce.date(),
6084
- updatedAt: z214.coerce.date(),
6091
+ elementPropertyOptionId: z215.string(),
6092
+ createdAt: z215.coerce.date(),
6093
+ updatedAt: z215.coerce.date(),
6085
6094
  origin: CollectionOrigin.optional()
6086
6095
  });
6087
- var DTOTokenCollectionsListReponse = z214.object({
6096
+ var DTOTokenCollectionsListReponse = z215.object({
6088
6097
  collections: DTOTokenCollection.array()
6089
6098
  });
6090
6099
 
6091
6100
  // src/api/dto/design-tokens/design-token.ts
6092
- import { z as z215 } from "zod";
6101
+ import { z as z216 } from "zod";
6093
6102
  var DTODesignToken = DesignTokenTypedData.and(
6094
- z215.object({
6095
- id: z215.string(),
6096
- persistentId: z215.string(),
6097
- designSystemVersionId: z215.string(),
6103
+ z216.object({
6104
+ id: z216.string(),
6105
+ persistentId: z216.string(),
6106
+ designSystemVersionId: z216.string(),
6098
6107
  meta: ObjectMeta,
6099
6108
  originStyle: DesignTokenOrigin.optional(),
6100
- brandId: z215.string(),
6101
- collectionId: z215.string().optional(),
6102
- updatedAt: z215.coerce.date()
6109
+ brandId: z216.string(),
6110
+ collectionId: z216.string().optional(),
6111
+ updatedAt: z216.coerce.date()
6103
6112
  })
6104
6113
  );
6105
- var DTODesignTokenListResponse = z215.object({
6114
+ var DTODesignTokenListResponse = z216.object({
6106
6115
  tokens: DTODesignToken.array()
6107
6116
  });
6108
- var DTODesignTokenResponse = z215.object({
6117
+ var DTODesignTokenResponse = z216.object({
6109
6118
  token: DTODesignToken
6110
6119
  });
6111
- var DTODesignTokenGroup = z215.object({
6112
- id: z215.string(),
6120
+ var DTODesignTokenGroup = z216.object({
6121
+ id: z216.string(),
6113
6122
  tokenType: DesignTokenType,
6114
- persistentId: z215.string(),
6115
- isRoot: z215.boolean(),
6116
- brandId: z215.string(),
6123
+ persistentId: z216.string(),
6124
+ isRoot: z216.boolean(),
6125
+ brandId: z216.string(),
6117
6126
  meta: ObjectMeta,
6118
- childrenIds: z215.string().array()
6127
+ childrenIds: z216.string().array()
6119
6128
  });
6120
- var DTODesignTokenGroupListResponse = z215.object({
6129
+ var DTODesignTokenGroupListResponse = z216.object({
6121
6130
  groups: DTODesignTokenGroup.array()
6122
6131
  });
6123
- var DTODesignTokenGroupResponse = z215.object({
6132
+ var DTODesignTokenGroupResponse = z216.object({
6124
6133
  group: DTODesignTokenGroup
6125
6134
  });
6126
6135
  var DTODesignTokenCreatePayload = DesignTokenTypedData.and(
6127
- z215.object({
6128
- persistentId: z215.string(),
6136
+ z216.object({
6137
+ persistentId: z216.string(),
6129
6138
  meta: ObjectMeta,
6130
- brandId: z215.string(),
6131
- groupPersistentId: z215.string().optional()
6139
+ brandId: z216.string(),
6140
+ groupPersistentId: z216.string().optional()
6132
6141
  })
6133
6142
  );
6134
- var DTODesignTokenGroupCreatePayload = z215.object({
6135
- persistentId: z215.string(),
6143
+ var DTODesignTokenGroupCreatePayload = z216.object({
6144
+ persistentId: z216.string(),
6136
6145
  meta: ObjectMeta,
6137
- brandId: z215.string(),
6138
- parentId: z215.string().optional(),
6146
+ brandId: z216.string(),
6147
+ parentId: z216.string().optional(),
6139
6148
  tokenType: DesignTokenType,
6140
- childrenIds: z215.string().array()
6149
+ childrenIds: z216.string().array()
6141
6150
  });
6142
6151
 
6143
6152
  // src/api/dto/documentation/anchor.ts
6144
- import { z as z216 } from "zod";
6153
+ import { z as z217 } from "zod";
6145
6154
  var DTODocumentationPageAnchor = DocumentationPageAnchor;
6146
- var DTOGetDocumentationPageAnchorsResponse = z216.object({
6147
- anchors: z216.array(DTODocumentationPageAnchor)
6155
+ var DTOGetDocumentationPageAnchorsResponse = z217.object({
6156
+ anchors: z217.array(DTODocumentationPageAnchor)
6148
6157
  });
6149
6158
 
6150
6159
  // src/api/dto/documentation/approvals.ts
6151
- import { z as z217 } from "zod";
6160
+ import { z as z218 } from "zod";
6152
6161
  var DTODocumentationPageApprovalState = DocumentationPageApproval;
6153
- var DTODocumentationGroupApprovalState = z217.object({
6154
- persistentId: z217.string(),
6155
- groupId: z217.string(),
6156
- designSystemVersionId: z217.string(),
6162
+ var DTODocumentationGroupApprovalState = z218.object({
6163
+ persistentId: z218.string(),
6164
+ groupId: z218.string(),
6165
+ designSystemVersionId: z218.string(),
6157
6166
  approvalState: DocumentationPageApprovalState
6158
6167
  });
6159
6168
 
@@ -6161,68 +6170,68 @@ var DTODocumentationGroupApprovalState = z217.object({
6161
6170
  var DTOPageBlockItemV2 = PageBlockItemV2;
6162
6171
 
6163
6172
  // src/api/dto/documentation/documentation-page-snapshot.ts
6164
- import { z as z222 } from "zod";
6173
+ import { z as z223 } from "zod";
6165
6174
 
6166
6175
  // src/api/dto/elements/documentation/page-v2.ts
6167
- import { z as z221 } from "zod";
6176
+ import { z as z222 } from "zod";
6168
6177
 
6169
6178
  // src/api/dto/elements/documentation/draft-state.ts
6170
- import { z as z219 } from "zod";
6179
+ import { z as z220 } from "zod";
6171
6180
 
6172
6181
  // src/api/dto/elements/documentation/item-configuration-v2.ts
6173
- import { z as z218 } from "zod";
6182
+ import { z as z219 } from "zod";
6174
6183
  var DTODocumentationItemHeaderV2 = DocumentationItemHeaderV2;
6175
- var DTODocumentationItemConfigurationV2 = z218.object({
6176
- showSidebar: z218.boolean(),
6177
- isPrivate: z218.boolean(),
6178
- isHidden: z218.boolean(),
6184
+ var DTODocumentationItemConfigurationV2 = z219.object({
6185
+ showSidebar: z219.boolean(),
6186
+ isPrivate: z219.boolean(),
6187
+ isHidden: z219.boolean(),
6179
6188
  header: DTODocumentationItemHeaderV2
6180
6189
  });
6181
6190
 
6182
6191
  // src/api/dto/elements/documentation/draft-state.ts
6183
- var DTODocumentationDraftChangeType = z219.enum(["Created", "Updated", "Deleted"]);
6184
- var DTODocumentationDraftStateCreated = z219.object({
6185
- changeType: z219.literal(DTODocumentationDraftChangeType.enum.Created)
6186
- });
6187
- var DTODocumentationDraftStateUpdated = z219.object({
6188
- changeType: z219.literal(DTODocumentationDraftChangeType.enum.Updated),
6189
- changes: z219.object({
6190
- previousTitle: z219.string().optional(),
6192
+ var DTODocumentationDraftChangeType = z220.enum(["Created", "Updated", "Deleted"]);
6193
+ var DTODocumentationDraftStateCreated = z220.object({
6194
+ changeType: z220.literal(DTODocumentationDraftChangeType.enum.Created)
6195
+ });
6196
+ var DTODocumentationDraftStateUpdated = z220.object({
6197
+ changeType: z220.literal(DTODocumentationDraftChangeType.enum.Updated),
6198
+ changes: z220.object({
6199
+ previousTitle: z220.string().optional(),
6191
6200
  previousConfiguration: DTODocumentationItemConfigurationV2.optional(),
6192
- previousContentHash: z219.string().optional()
6201
+ previousContentHash: z220.string().optional()
6193
6202
  })
6194
6203
  });
6195
- var DTODocumentationDraftStateDeleted = z219.object({
6196
- changeType: z219.literal(DTODocumentationDraftChangeType.enum.Deleted),
6197
- deletedAt: z219.coerce.date(),
6198
- deletedByUserId: z219.string()
6204
+ var DTODocumentationDraftStateDeleted = z220.object({
6205
+ changeType: z220.literal(DTODocumentationDraftChangeType.enum.Deleted),
6206
+ deletedAt: z220.coerce.date(),
6207
+ deletedByUserId: z220.string()
6199
6208
  });
6200
- var DTODocumentationDraftState = z219.discriminatedUnion("changeType", [
6209
+ var DTODocumentationDraftState = z220.discriminatedUnion("changeType", [
6201
6210
  DTODocumentationDraftStateCreated,
6202
6211
  DTODocumentationDraftStateUpdated,
6203
6212
  DTODocumentationDraftStateDeleted
6204
6213
  ]);
6205
6214
 
6206
6215
  // src/api/dto/elements/documentation/metadata.ts
6207
- import { z as z220 } from "zod";
6208
- var DTODocumentationPublishMetadata = z220.object({
6209
- lastPublishedByUserId: z220.string(),
6210
- lastPublishedAt: z220.coerce.date()
6216
+ import { z as z221 } from "zod";
6217
+ var DTODocumentationPublishMetadata = z221.object({
6218
+ lastPublishedByUserId: z221.string(),
6219
+ lastPublishedAt: z221.coerce.date()
6211
6220
  });
6212
6221
 
6213
6222
  // src/api/dto/elements/documentation/page-v2.ts
6214
- var DTODocumentationPageV2 = z221.object({
6215
- id: z221.string(),
6216
- persistentId: z221.string(),
6217
- designSystemVersionId: z221.string(),
6218
- title: z221.string(),
6223
+ var DTODocumentationPageV2 = z222.object({
6224
+ id: z222.string(),
6225
+ persistentId: z222.string(),
6226
+ designSystemVersionId: z222.string(),
6227
+ title: z222.string(),
6219
6228
  configuration: DTODocumentationItemConfigurationV2,
6220
- shortPersistentId: z221.string(),
6221
- slug: z221.string().optional(),
6222
- userSlug: z221.string().optional(),
6223
- createdAt: z221.coerce.date(),
6224
- updatedAt: z221.coerce.date(),
6225
- path: z221.string(),
6229
+ shortPersistentId: z222.string(),
6230
+ slug: z222.string().optional(),
6231
+ userSlug: z222.string().optional(),
6232
+ createdAt: z222.coerce.date(),
6233
+ updatedAt: z222.coerce.date(),
6234
+ path: z222.string(),
6226
6235
  /** Defined when a page has changed since last publish and can be included into a partial publish */
6227
6236
  draftState: DTODocumentationDraftState.optional(),
6228
6237
  /** Defined if a page was published at least once and contains metadata about last publish */
@@ -6230,218 +6239,218 @@ var DTODocumentationPageV2 = z221.object({
6230
6239
  /** Defines the approval state of the documentation page */
6231
6240
  approvalState: DTODocumentationPageApprovalState.optional(),
6232
6241
  // Backward compatibility
6233
- type: z221.literal("Page")
6242
+ type: z222.literal("Page")
6234
6243
  });
6235
- var DTOCreateDocumentationPageInputV2 = z221.object({
6244
+ var DTOCreateDocumentationPageInputV2 = z222.object({
6236
6245
  // Identifier
6237
- persistentId: z221.string(),
6246
+ persistentId: z222.string(),
6238
6247
  // Page properties
6239
- title: z221.string(),
6248
+ title: z222.string(),
6240
6249
  configuration: DTODocumentationItemConfigurationV2.partial().optional(),
6241
6250
  // Page placement properties
6242
- parentPersistentId: z221.string(),
6243
- afterPersistentId: z221.string().nullish()
6251
+ parentPersistentId: z222.string(),
6252
+ afterPersistentId: z222.string().nullish()
6244
6253
  });
6245
- var DTOUpdateDocumentationPageInputV2 = z221.object({
6254
+ var DTOUpdateDocumentationPageInputV2 = z222.object({
6246
6255
  // Identifier of the group to update
6247
- id: z221.string(),
6256
+ id: z222.string(),
6248
6257
  // Page properties
6249
- title: z221.string().optional(),
6258
+ title: z222.string().optional(),
6250
6259
  configuration: DTODocumentationItemConfigurationV2.partial().optional()
6251
6260
  });
6252
- var DTOMoveDocumentationPageInputV2 = z221.object({
6261
+ var DTOMoveDocumentationPageInputV2 = z222.object({
6253
6262
  // Identifier of the group to update
6254
- id: z221.string(),
6263
+ id: z222.string(),
6255
6264
  // Page placement properties
6256
- parentPersistentId: z221.string(),
6257
- afterPersistentId: z221.string().nullish()
6265
+ parentPersistentId: z222.string(),
6266
+ afterPersistentId: z222.string().nullish()
6258
6267
  });
6259
- var DTODuplicateDocumentationPageInputV2 = z221.object({
6268
+ var DTODuplicateDocumentationPageInputV2 = z222.object({
6260
6269
  // Identifier of the page to duplicate from
6261
- id: z221.string(),
6270
+ id: z222.string(),
6262
6271
  // New page persistent id
6263
- persistentId: z221.string(),
6272
+ persistentId: z222.string(),
6264
6273
  // Page placement properties
6265
- parentPersistentId: z221.string(),
6266
- afterPersistentId: z221.string().nullish()
6274
+ parentPersistentId: z222.string(),
6275
+ afterPersistentId: z222.string().nullish()
6267
6276
  });
6268
- var DTODeleteDocumentationPageInputV2 = z221.object({
6277
+ var DTODeleteDocumentationPageInputV2 = z222.object({
6269
6278
  // Identifier
6270
- id: z221.string()
6279
+ id: z222.string()
6271
6280
  });
6272
- var DTORestoreDocumentationPageInput = z221.object({
6273
- persistentId: z221.string(),
6274
- snapshotId: z221.string().optional()
6281
+ var DTORestoreDocumentationPageInput = z222.object({
6282
+ persistentId: z222.string(),
6283
+ snapshotId: z222.string().optional()
6275
6284
  });
6276
- var DTORestoreDocumentationGroupInput = z221.object({
6277
- persistentId: z221.string(),
6278
- snapshotId: z221.string().optional()
6285
+ var DTORestoreDocumentationGroupInput = z222.object({
6286
+ persistentId: z222.string(),
6287
+ snapshotId: z222.string().optional()
6279
6288
  });
6280
- var DTODocumentationPageApprovalStateChangeInput = z221.object({
6281
- persistentId: z221.string(),
6289
+ var DTODocumentationPageApprovalStateChangeInput = z222.object({
6290
+ persistentId: z222.string(),
6282
6291
  approvalState: DocumentationPageApprovalState.optional()
6283
6292
  });
6284
6293
 
6285
6294
  // src/api/dto/documentation/documentation-page-snapshot.ts
6286
- var DTODocumentationPageSnapshot = z222.object({
6287
- id: z222.string(),
6288
- designSystemVersionId: z222.string(),
6289
- createdAt: z222.string(),
6290
- updatedAt: z222.string(),
6295
+ var DTODocumentationPageSnapshot = z223.object({
6296
+ id: z223.string(),
6297
+ designSystemVersionId: z223.string(),
6298
+ createdAt: z223.string(),
6299
+ updatedAt: z223.string(),
6291
6300
  documentationPage: DTODocumentationPageV2,
6292
- pageContentHash: z222.string(),
6301
+ pageContentHash: z223.string(),
6293
6302
  reason: DesignElementSnapshotReason
6294
6303
  });
6295
6304
 
6296
6305
  // src/api/dto/documentation/link-preview.ts
6297
- import { z as z223 } from "zod";
6298
- var DTODocumentationLinkPreviewResponse = z223.object({
6306
+ import { z as z224 } from "zod";
6307
+ var DTODocumentationLinkPreviewResponse = z224.object({
6299
6308
  linkPreview: DocumentationLinkPreview
6300
6309
  });
6301
- var DTODocumentationLinkPreviewRequest = z223.object({
6302
- url: z223.string().optional(),
6303
- documentationItemPersistentId: z223.string().optional()
6310
+ var DTODocumentationLinkPreviewRequest = z224.object({
6311
+ url: z224.string().optional(),
6312
+ documentationItemPersistentId: z224.string().optional()
6304
6313
  });
6305
6314
 
6306
6315
  // src/api/dto/documentation/publish.ts
6307
- import { z as z227 } from "zod";
6316
+ import { z as z228 } from "zod";
6308
6317
 
6309
6318
  // src/api/dto/export/exporter.ts
6310
- import { z as z224 } from "zod";
6311
- var DTOExporterType = z224.enum(["documentation", "code"]);
6312
- var DTOExporterSource = z224.enum(["git", "upload"]);
6313
- var DTOExporterMembershipRole = z224.enum(["Owner", "OwnerArchived", "User"]);
6314
- var DTOExporterListQuery = z224.object({
6315
- limit: z224.coerce.number().optional()
6316
- });
6317
- var DTOExporter = z224.object({
6318
- id: z224.string(),
6319
- name: z224.string(),
6320
- isPrivate: z224.boolean(),
6319
+ import { z as z225 } from "zod";
6320
+ var DTOExporterType = z225.enum(["documentation", "code"]);
6321
+ var DTOExporterSource = z225.enum(["git", "upload"]);
6322
+ var DTOExporterMembershipRole = z225.enum(["Owner", "OwnerArchived", "User"]);
6323
+ var DTOExporterListQuery = z225.object({
6324
+ limit: z225.coerce.number().optional()
6325
+ });
6326
+ var DTOExporter = z225.object({
6327
+ id: z225.string(),
6328
+ name: z225.string(),
6329
+ isPrivate: z225.boolean(),
6321
6330
  exporterType: DTOExporterType,
6322
- isDefaultDocumentationExporter: z224.boolean(),
6323
- iconURL: z224.string().optional(),
6331
+ isDefaultDocumentationExporter: z225.boolean(),
6332
+ iconURL: z225.string().optional(),
6324
6333
  configurationProperties: PulsarContributionConfigurationProperty.array(),
6325
6334
  properties: DTOExporterPropertyDefinition.array().optional(),
6326
6335
  customBlocks: PulsarCustomBlock.array(),
6327
- blockVariants: z224.record(z224.string(), PulsarContributionVariant.array()),
6328
- usesBrands: z224.boolean(),
6329
- usesThemes: z224.boolean(),
6336
+ blockVariants: z225.record(z225.string(), PulsarContributionVariant.array()),
6337
+ usesBrands: z225.boolean(),
6338
+ usesThemes: z225.boolean(),
6330
6339
  source: DTOExporterSource,
6331
- gitUrl: nullishToOptional(z224.string()),
6332
- gitBranch: nullishToOptional(z224.string()),
6333
- gitDirectory: nullishToOptional(z224.string())
6340
+ gitUrl: nullishToOptional(z225.string()),
6341
+ gitBranch: nullishToOptional(z225.string()),
6342
+ gitDirectory: nullishToOptional(z225.string())
6334
6343
  });
6335
- var DTOExporterMembership = z224.object({
6336
- workspaceId: z224.string(),
6337
- exporterId: z224.string(),
6344
+ var DTOExporterMembership = z225.object({
6345
+ workspaceId: z225.string(),
6346
+ exporterId: z225.string(),
6338
6347
  role: DTOExporterMembershipRole
6339
6348
  });
6340
- var DTOExporterCreateOutput = z224.object({
6349
+ var DTOExporterCreateOutput = z225.object({
6341
6350
  exporter: DTOExporter,
6342
6351
  membership: DTOExporterMembership
6343
6352
  });
6344
- var DTOExporterListResponse = z224.object({
6353
+ var DTOExporterListResponse = z225.object({
6345
6354
  exporters: DTOExporter.array(),
6346
6355
  membership: DTOExporterMembership.array()
6347
6356
  });
6348
- var DTOExporterGitProviderEnum = z224.enum(["github", "gitlab", "bitbucket", "azure"]);
6349
- var DTOExporterCreateInput = z224.object({
6350
- url: z224.string(),
6357
+ var DTOExporterGitProviderEnum = z225.enum(["github", "gitlab", "bitbucket", "azure"]);
6358
+ var DTOExporterCreateInput = z225.object({
6359
+ url: z225.string(),
6351
6360
  provider: DTOExporterGitProviderEnum
6352
6361
  });
6353
- var DTOExporterUpdateInput = z224.object({
6354
- url: z224.string().optional()
6362
+ var DTOExporterUpdateInput = z225.object({
6363
+ url: z225.string().optional()
6355
6364
  });
6356
6365
 
6357
6366
  // src/api/dto/export/filter.ts
6358
6367
  var DTOExportJobsListFilter = ExportJobFindByFilter;
6359
6368
 
6360
6369
  // src/api/dto/export/job.ts
6361
- import { z as z225 } from "zod";
6362
- var DTOExportJobCreatedBy = z225.object({
6363
- userId: z225.string(),
6364
- userName: z225.string()
6370
+ import { z as z226 } from "zod";
6371
+ var DTOExportJobCreatedBy = z226.object({
6372
+ userId: z226.string(),
6373
+ userName: z226.string()
6365
6374
  });
6366
- var DTOExportJobDesignSystemPreview = z225.object({
6367
- id: z225.string(),
6375
+ var DTOExportJobDesignSystemPreview = z226.object({
6376
+ id: z226.string(),
6368
6377
  meta: ObjectMeta
6369
6378
  });
6370
- var DTOExportJobDesignSystemVersionPreview = z225.object({
6371
- id: z225.string(),
6379
+ var DTOExportJobDesignSystemVersionPreview = z226.object({
6380
+ id: z226.string(),
6372
6381
  meta: ObjectMeta,
6373
- version: z225.string(),
6374
- isReadonly: z225.boolean()
6382
+ version: z226.string(),
6383
+ isReadonly: z226.boolean()
6375
6384
  });
6376
- var DTOExportJobDestinations = z225.object({
6385
+ var DTOExportJobDestinations = z226.object({
6377
6386
  s3: ExporterDestinationS3.optional(),
6378
6387
  azure: ExporterDestinationAzure.optional(),
6379
6388
  bitbucket: ExporterDestinationBitbucket.optional(),
6380
6389
  github: ExporterDestinationGithub.optional(),
6381
6390
  gitlab: ExporterDestinationGitlab.optional(),
6382
6391
  documentation: ExporterDestinationDocs.optional(),
6383
- webhookUrl: z225.string().optional()
6392
+ webhookUrl: z226.string().optional()
6384
6393
  });
6385
6394
  var DTOExportJobResult = ExportJobResult.omit({
6386
6395
  sndocs: true
6387
6396
  }).extend({
6388
6397
  documentation: ExportJobDocsDestinationResult.optional()
6389
6398
  });
6390
- var DTOExportJob = z225.object({
6391
- id: z225.string(),
6392
- createdAt: z225.coerce.date(),
6393
- finishedAt: z225.coerce.date().optional(),
6394
- index: z225.number().optional(),
6399
+ var DTOExportJob = z226.object({
6400
+ id: z226.string(),
6401
+ createdAt: z226.coerce.date(),
6402
+ finishedAt: z226.coerce.date().optional(),
6403
+ index: z226.number().optional(),
6395
6404
  status: ExportJobStatus,
6396
- estimatedExecutionTime: z225.number().optional(),
6405
+ estimatedExecutionTime: z226.number().optional(),
6397
6406
  createdBy: DTOExportJobCreatedBy.optional(),
6398
6407
  designSystem: DTOExportJobDesignSystemPreview,
6399
6408
  designSystemVersion: DTOExportJobDesignSystemVersionPreview,
6400
6409
  destinations: DTOExportJobDestinations,
6401
- exporterId: z225.string(),
6402
- scheduleId: z225.string().optional(),
6410
+ exporterId: z226.string(),
6411
+ scheduleId: z226.string().optional(),
6403
6412
  result: DTOExportJobResult.optional(),
6404
- brandPersistentId: z225.string().optional(),
6405
- themePersistentId: z225.string().optional(),
6406
- themePersistentIds: z225.string().array().optional(),
6413
+ brandPersistentId: z226.string().optional(),
6414
+ themePersistentId: z226.string().optional(),
6415
+ themePersistentIds: z226.string().array().optional(),
6407
6416
  exporterConfiguration: DTOExporterPropertyDefinitionValueMap.optional()
6408
6417
  });
6409
- var DTOExportJobResponse = z225.object({
6418
+ var DTOExportJobResponse = z226.object({
6410
6419
  job: DTOExportJob
6411
6420
  });
6412
6421
 
6413
6422
  // src/api/dto/export/pipeline.ts
6414
- import { z as z226 } from "zod";
6415
- var DTOPipelineListQuery = z226.object({
6416
- designSystemId: z226.string().optional(),
6417
- exporterId: z226.string().optional(),
6418
- latestJobsLimit: z226.coerce.number().optional()
6419
- });
6420
- var DTOPipeline = z226.object({
6421
- id: z226.string(),
6422
- name: z226.string(),
6423
+ import { z as z227 } from "zod";
6424
+ var DTOPipelineListQuery = z227.object({
6425
+ designSystemId: z227.string().optional(),
6426
+ exporterId: z227.string().optional(),
6427
+ latestJobsLimit: z227.coerce.number().optional()
6428
+ });
6429
+ var DTOPipeline = z227.object({
6430
+ id: z227.string(),
6431
+ name: z227.string(),
6423
6432
  eventType: PipelineEventType,
6424
- isEnabled: z226.boolean(),
6425
- workspaceId: z226.string(),
6426
- designSystemId: z226.string(),
6427
- exporterId: z226.string(),
6428
- brandPersistentId: z226.string().optional(),
6429
- themePersistentId: z226.string().optional(),
6430
- themePersistentIds: z226.string().array().optional(),
6433
+ isEnabled: z227.boolean(),
6434
+ workspaceId: z227.string(),
6435
+ designSystemId: z227.string(),
6436
+ exporterId: z227.string(),
6437
+ brandPersistentId: z227.string().optional(),
6438
+ themePersistentId: z227.string().optional(),
6439
+ themePersistentIds: z227.string().array().optional(),
6431
6440
  exporterConfiguration: DTOExporterPropertyDefinitionValueMap.optional(),
6432
6441
  ...ExportDestinationsMap.shape,
6433
6442
  latestJobs: DTOExportJob.array()
6434
6443
  });
6435
- var DTOPipelineListResponse = z226.object({
6444
+ var DTOPipelineListResponse = z227.object({
6436
6445
  pipelines: DTOPipeline.array()
6437
6446
  });
6438
- var DTOPipelineResponse = z226.object({
6447
+ var DTOPipelineResponse = z227.object({
6439
6448
  pipeline: DTOPipeline
6440
6449
  });
6441
6450
 
6442
6451
  // src/api/dto/documentation/publish.ts
6443
6452
  var DTOPublishDocumentationChanges = ExportJobDocumentationChanges;
6444
- var DTOPublishDocumentationRequest = z227.object({
6453
+ var DTOPublishDocumentationRequest = z228.object({
6445
6454
  environment: PublishedDocEnvironment,
6446
6455
  /**
6447
6456
  * If defined, this allows narrowing down what is published to a set of specific pages and groups
@@ -6449,57 +6458,57 @@ var DTOPublishDocumentationRequest = z227.object({
6449
6458
  */
6450
6459
  changes: DTOPublishDocumentationChanges.optional()
6451
6460
  });
6452
- var DTOPublishDocumentationResponse = z227.object({
6461
+ var DTOPublishDocumentationResponse = z228.object({
6453
6462
  job: DTOExportJob
6454
6463
  });
6455
6464
 
6456
6465
  // src/api/dto/elements/components/figma-component-group.ts
6457
- import z228 from "zod";
6458
- var DTOFigmaComponentGroup = z228.object({
6459
- id: z228.string(),
6460
- designSystemVersionId: z228.string(),
6461
- persistentId: z228.string(),
6462
- isRoot: z228.boolean(),
6463
- brandId: z228.string(),
6466
+ import z229 from "zod";
6467
+ var DTOFigmaComponentGroup = z229.object({
6468
+ id: z229.string(),
6469
+ designSystemVersionId: z229.string(),
6470
+ persistentId: z229.string(),
6471
+ isRoot: z229.boolean(),
6472
+ brandId: z229.string(),
6464
6473
  meta: DTOObjectMeta,
6465
- childrenIds: z228.string().array()
6474
+ childrenIds: z229.string().array()
6466
6475
  });
6467
- var DTOFigmaComponentGroupListResponse = z228.object({
6476
+ var DTOFigmaComponentGroupListResponse = z229.object({
6468
6477
  groups: DTOFigmaComponentGroup.array()
6469
6478
  });
6470
6479
 
6471
6480
  // src/api/dto/elements/components/figma-component.ts
6472
- import { z as z229 } from "zod";
6481
+ import { z as z230 } from "zod";
6473
6482
  var DTOFigmaComponentProperty = FigmaComponentProperty;
6474
- var DTOFigmaComponentPropertyMap = z229.record(DTOFigmaComponentProperty);
6475
- var DTOFigmaComponent = z229.object({
6476
- id: z229.string(),
6477
- persistentId: z229.string(),
6478
- designSystemVersionId: z229.string(),
6479
- brandId: z229.string(),
6480
- thumbnailUrl: z229.string().optional(),
6481
- svgUrl: z229.string().optional(),
6482
- exportProperties: z229.object({
6483
- isAsset: z229.boolean()
6483
+ var DTOFigmaComponentPropertyMap = z230.record(DTOFigmaComponentProperty);
6484
+ var DTOFigmaComponent = z230.object({
6485
+ id: z230.string(),
6486
+ persistentId: z230.string(),
6487
+ designSystemVersionId: z230.string(),
6488
+ brandId: z230.string(),
6489
+ thumbnailUrl: z230.string().optional(),
6490
+ svgUrl: z230.string().optional(),
6491
+ exportProperties: z230.object({
6492
+ isAsset: z230.boolean()
6484
6493
  }),
6485
- createdAt: z229.coerce.date(),
6486
- updatedAt: z229.coerce.date(),
6494
+ createdAt: z230.coerce.date(),
6495
+ updatedAt: z230.coerce.date(),
6487
6496
  meta: ObjectMeta,
6488
6497
  originComponent: FigmaComponentOrigin.optional(),
6489
- parentComponentPersistentId: z229.string().optional(),
6490
- childrenPersistentIds: z229.string().array().optional(),
6498
+ parentComponentPersistentId: z230.string().optional(),
6499
+ childrenPersistentIds: z230.string().array().optional(),
6491
6500
  componentPropertyDefinitions: DTOFigmaComponentPropertyMap.optional(),
6492
- variantPropertyValues: z229.record(z229.string()).optional()
6501
+ variantPropertyValues: z230.record(z230.string()).optional()
6493
6502
  });
6494
- var DTOFigmaComponentListResponse = z229.object({
6503
+ var DTOFigmaComponentListResponse = z230.object({
6495
6504
  components: DTOFigmaComponent.array()
6496
6505
  });
6497
6506
 
6498
6507
  // src/api/dto/elements/documentation/group-action.ts
6499
- import { z as z231 } from "zod";
6508
+ import { z as z232 } from "zod";
6500
6509
 
6501
6510
  // src/api/dto/elements/documentation/group-v2.ts
6502
- import { z as z230 } from "zod";
6511
+ import { z as z231 } from "zod";
6503
6512
  var DTODocumentationGroupV2 = ElementGroup.omit({
6504
6513
  sortOrder: true,
6505
6514
  parentPersistentId: true,
@@ -6509,13 +6518,13 @@ var DTODocumentationGroupV2 = ElementGroup.omit({
6509
6518
  data: true,
6510
6519
  shortPersistentId: true
6511
6520
  }).extend({
6512
- title: z230.string(),
6513
- isRoot: z230.boolean(),
6514
- childrenIds: z230.array(z230.string()),
6521
+ title: z231.string(),
6522
+ isRoot: z231.boolean(),
6523
+ childrenIds: z231.array(z231.string()),
6515
6524
  groupBehavior: DocumentationGroupBehavior,
6516
- shortPersistentId: z230.string(),
6525
+ shortPersistentId: z231.string(),
6517
6526
  configuration: DTODocumentationItemConfigurationV2,
6518
- type: z230.literal("Group"),
6527
+ type: z231.literal("Group"),
6519
6528
  /** Defined when a group has changed since last publish and can be included into a partial publish */
6520
6529
  draftState: DTODocumentationDraftState.optional(),
6521
6530
  /** Defined if a group was published at least once and contains metadata about last publish */
@@ -6523,127 +6532,127 @@ var DTODocumentationGroupV2 = ElementGroup.omit({
6523
6532
  //** An approval state for frontend to utilize. */
6524
6533
  approvalState: DTODocumentationGroupApprovalState.optional()
6525
6534
  });
6526
- var DTOCreateDocumentationGroupInput = z230.object({
6535
+ var DTOCreateDocumentationGroupInput = z231.object({
6527
6536
  // Identifier
6528
- persistentId: z230.string(),
6537
+ persistentId: z231.string(),
6529
6538
  // Group properties
6530
- title: z230.string(),
6539
+ title: z231.string(),
6531
6540
  configuration: DTODocumentationItemConfigurationV2.partial().optional(),
6532
6541
  // Group placement properties
6533
- afterPersistentId: z230.string().nullish(),
6534
- parentPersistentId: z230.string()
6542
+ afterPersistentId: z231.string().nullish(),
6543
+ parentPersistentId: z231.string()
6535
6544
  });
6536
- var DTOUpdateDocumentationGroupInput = z230.object({
6545
+ var DTOUpdateDocumentationGroupInput = z231.object({
6537
6546
  // Identifier of the group to update
6538
- id: z230.string(),
6547
+ id: z231.string(),
6539
6548
  // Group properties
6540
- title: z230.string().optional(),
6549
+ title: z231.string().optional(),
6541
6550
  configuration: DTODocumentationItemConfigurationV2.partial().optional()
6542
6551
  });
6543
- var DTOMoveDocumentationGroupInput = z230.object({
6552
+ var DTOMoveDocumentationGroupInput = z231.object({
6544
6553
  // Identifier of the group to update
6545
- id: z230.string(),
6554
+ id: z231.string(),
6546
6555
  // Group placement properties
6547
- parentPersistentId: z230.string(),
6548
- afterPersistentId: z230.string().nullish()
6556
+ parentPersistentId: z231.string(),
6557
+ afterPersistentId: z231.string().nullish()
6549
6558
  });
6550
- var DTODuplicateDocumentationGroupInput = z230.object({
6559
+ var DTODuplicateDocumentationGroupInput = z231.object({
6551
6560
  // Identifier of the group to duplicate from
6552
- id: z230.string(),
6561
+ id: z231.string(),
6553
6562
  // New group persistent id
6554
- persistentId: z230.string(),
6563
+ persistentId: z231.string(),
6555
6564
  // Group placement properties
6556
- afterPersistentId: z230.string().nullish(),
6557
- parentPersistentId: z230.string()
6565
+ afterPersistentId: z231.string().nullish(),
6566
+ parentPersistentId: z231.string()
6558
6567
  });
6559
- var DTOCreateDocumentationTabInput = z230.object({
6568
+ var DTOCreateDocumentationTabInput = z231.object({
6560
6569
  // New group persistent id
6561
- persistentId: z230.string(),
6570
+ persistentId: z231.string(),
6562
6571
  // If this is page, we will attempt to convert it to tab
6563
6572
  // If this is tab group, we will add a new tab to it
6564
- fromItemPersistentId: z230.string(),
6565
- tabName: z230.string()
6573
+ fromItemPersistentId: z231.string(),
6574
+ tabName: z231.string()
6566
6575
  });
6567
- var DTODeleteDocumentationTabGroupInput = z230.object({
6576
+ var DTODeleteDocumentationTabGroupInput = z231.object({
6568
6577
  // Deleted group id
6569
- id: z230.string()
6578
+ id: z231.string()
6570
6579
  });
6571
- var DTODeleteDocumentationGroupInput = z230.object({
6580
+ var DTODeleteDocumentationGroupInput = z231.object({
6572
6581
  // Identifier
6573
- id: z230.string(),
6582
+ id: z231.string(),
6574
6583
  // Deletion options
6575
- deleteSubtree: z230.boolean().default(false)
6584
+ deleteSubtree: z231.boolean().default(false)
6576
6585
  });
6577
6586
 
6578
6587
  // src/api/dto/elements/documentation/group-action.ts
6579
- var SuccessPayload = z231.object({
6580
- success: z231.literal(true)
6588
+ var SuccessPayload = z232.object({
6589
+ success: z232.literal(true)
6581
6590
  });
6582
- var DTODocumentationGroupCreateActionOutputV2 = z231.object({
6583
- type: z231.literal("DocumentationGroupCreate"),
6591
+ var DTODocumentationGroupCreateActionOutputV2 = z232.object({
6592
+ type: z232.literal("DocumentationGroupCreate"),
6584
6593
  output: SuccessPayload
6585
6594
  });
6586
- var DTODocumentationTabCreateActionOutputV2 = z231.object({
6587
- type: z231.literal("DocumentationTabCreate"),
6595
+ var DTODocumentationTabCreateActionOutputV2 = z232.object({
6596
+ type: z232.literal("DocumentationTabCreate"),
6588
6597
  output: SuccessPayload
6589
6598
  });
6590
- var DTODocumentationGroupUpdateActionOutputV2 = z231.object({
6591
- type: z231.literal("DocumentationGroupUpdate"),
6599
+ var DTODocumentationGroupUpdateActionOutputV2 = z232.object({
6600
+ type: z232.literal("DocumentationGroupUpdate"),
6592
6601
  output: SuccessPayload
6593
6602
  });
6594
- var DTODocumentationGroupMoveActionOutputV2 = z231.object({
6595
- type: z231.literal("DocumentationGroupMove"),
6603
+ var DTODocumentationGroupMoveActionOutputV2 = z232.object({
6604
+ type: z232.literal("DocumentationGroupMove"),
6596
6605
  output: SuccessPayload
6597
6606
  });
6598
- var DTODocumentationGroupDuplicateActionOutputV2 = z231.object({
6599
- type: z231.literal("DocumentationGroupDuplicate"),
6607
+ var DTODocumentationGroupDuplicateActionOutputV2 = z232.object({
6608
+ type: z232.literal("DocumentationGroupDuplicate"),
6600
6609
  output: SuccessPayload
6601
6610
  });
6602
- var DTODocumentationGroupDeleteActionOutputV2 = z231.object({
6603
- type: z231.literal("DocumentationGroupDelete"),
6611
+ var DTODocumentationGroupDeleteActionOutputV2 = z232.object({
6612
+ type: z232.literal("DocumentationGroupDelete"),
6604
6613
  output: SuccessPayload
6605
6614
  });
6606
- var DTODocumentationTabGroupDeleteActionOutputV2 = z231.object({
6607
- type: z231.literal("DocumentationTabGroupDelete"),
6615
+ var DTODocumentationTabGroupDeleteActionOutputV2 = z232.object({
6616
+ type: z232.literal("DocumentationTabGroupDelete"),
6608
6617
  output: SuccessPayload
6609
6618
  });
6610
- var DTODocumentationGroupCreateActionInputV2 = z231.object({
6611
- type: z231.literal("DocumentationGroupCreate"),
6619
+ var DTODocumentationGroupCreateActionInputV2 = z232.object({
6620
+ type: z232.literal("DocumentationGroupCreate"),
6612
6621
  input: DTOCreateDocumentationGroupInput
6613
6622
  });
6614
- var DTODocumentationTabCreateActionInputV2 = z231.object({
6615
- type: z231.literal("DocumentationTabCreate"),
6623
+ var DTODocumentationTabCreateActionInputV2 = z232.object({
6624
+ type: z232.literal("DocumentationTabCreate"),
6616
6625
  input: DTOCreateDocumentationTabInput
6617
6626
  });
6618
- var DTODocumentationGroupUpdateActionInputV2 = z231.object({
6619
- type: z231.literal("DocumentationGroupUpdate"),
6627
+ var DTODocumentationGroupUpdateActionInputV2 = z232.object({
6628
+ type: z232.literal("DocumentationGroupUpdate"),
6620
6629
  input: DTOUpdateDocumentationGroupInput
6621
6630
  });
6622
- var DTODocumentationGroupMoveActionInputV2 = z231.object({
6623
- type: z231.literal("DocumentationGroupMove"),
6631
+ var DTODocumentationGroupMoveActionInputV2 = z232.object({
6632
+ type: z232.literal("DocumentationGroupMove"),
6624
6633
  input: DTOMoveDocumentationGroupInput
6625
6634
  });
6626
- var DTODocumentationGroupDuplicateActionInputV2 = z231.object({
6627
- type: z231.literal("DocumentationGroupDuplicate"),
6635
+ var DTODocumentationGroupDuplicateActionInputV2 = z232.object({
6636
+ type: z232.literal("DocumentationGroupDuplicate"),
6628
6637
  input: DTODuplicateDocumentationGroupInput
6629
6638
  });
6630
- var DTODocumentationGroupDeleteActionInputV2 = z231.object({
6631
- type: z231.literal("DocumentationGroupDelete"),
6639
+ var DTODocumentationGroupDeleteActionInputV2 = z232.object({
6640
+ type: z232.literal("DocumentationGroupDelete"),
6632
6641
  input: DTODeleteDocumentationGroupInput
6633
6642
  });
6634
- var DTODocumentationTabGroupDeleteActionInputV2 = z231.object({
6635
- type: z231.literal("DocumentationTabGroupDelete"),
6643
+ var DTODocumentationTabGroupDeleteActionInputV2 = z232.object({
6644
+ type: z232.literal("DocumentationTabGroupDelete"),
6636
6645
  input: DTODeleteDocumentationTabGroupInput
6637
6646
  });
6638
6647
 
6639
6648
  // src/api/dto/elements/documentation/group-v1.ts
6640
- import { z as z233 } from "zod";
6649
+ import { z as z234 } from "zod";
6641
6650
 
6642
6651
  // src/api/dto/elements/documentation/item-configuration-v1.ts
6643
- import { z as z232 } from "zod";
6644
- var DocumentationColorV1 = z232.object({
6645
- aliasTo: z232.string().optional(),
6646
- value: z232.string().optional()
6652
+ import { z as z233 } from "zod";
6653
+ var DocumentationColorV1 = z233.object({
6654
+ aliasTo: z233.string().optional(),
6655
+ value: z233.string().optional()
6647
6656
  });
6648
6657
  var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
6649
6658
  foregroundColor: true,
@@ -6652,10 +6661,10 @@ var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
6652
6661
  foregroundColor: DocumentationColorV1.optional(),
6653
6662
  backgroundColor: DocumentationColorV1.optional()
6654
6663
  });
6655
- var DTODocumentationItemConfigurationV1 = z232.object({
6656
- showSidebar: z232.boolean(),
6657
- isPrivate: z232.boolean(),
6658
- isHidden: z232.boolean(),
6664
+ var DTODocumentationItemConfigurationV1 = z233.object({
6665
+ showSidebar: z233.boolean(),
6666
+ isPrivate: z233.boolean(),
6667
+ isHidden: z233.boolean(),
6659
6668
  header: DTODocumentationItemHeaderV1
6660
6669
  });
6661
6670
 
@@ -6669,27 +6678,27 @@ var DTODocumentationGroupStructureV1 = ElementGroup.omit({
6669
6678
  data: true,
6670
6679
  shortPersistentId: true
6671
6680
  }).extend({
6672
- title: z233.string(),
6673
- isRoot: z233.boolean(),
6674
- childrenIds: z233.array(z233.string()),
6681
+ title: z234.string(),
6682
+ isRoot: z234.boolean(),
6683
+ childrenIds: z234.array(z234.string()),
6675
6684
  groupBehavior: DocumentationGroupBehavior,
6676
- shortPersistentId: z233.string(),
6677
- type: z233.literal("Group")
6685
+ shortPersistentId: z234.string(),
6686
+ type: z234.literal("Group")
6678
6687
  });
6679
6688
  var DTODocumentationGroupV1 = DTODocumentationGroupStructureV1.extend({
6680
6689
  configuration: DTODocumentationItemConfigurationV1
6681
6690
  });
6682
6691
 
6683
6692
  // src/api/dto/elements/documentation/hierarchy.ts
6684
- import { z as z234 } from "zod";
6685
- var DTODocumentationHierarchyV2 = z234.object({
6686
- pages: z234.array(
6693
+ import { z as z235 } from "zod";
6694
+ var DTODocumentationHierarchyV2 = z235.object({
6695
+ pages: z235.array(
6687
6696
  DTODocumentationPageV2.extend({
6688
6697
  /** Defined when a page has changed since last publish and can be included into a partial publish */
6689
6698
  draftState: DTODocumentationDraftState.optional()
6690
6699
  })
6691
6700
  ),
6692
- groups: z234.array(
6701
+ groups: z235.array(
6693
6702
  DTODocumentationGroupV2.extend({
6694
6703
  /** Defined when a page has changed since last publish and can be included into a partial publish */
6695
6704
  draftState: DTODocumentationDraftState.optional()
@@ -6698,84 +6707,84 @@ var DTODocumentationHierarchyV2 = z234.object({
6698
6707
  });
6699
6708
 
6700
6709
  // src/api/dto/elements/documentation/page-actions-v2.ts
6701
- import { z as z235 } from "zod";
6702
- var SuccessPayload2 = z235.object({
6703
- success: z235.literal(true)
6710
+ import { z as z236 } from "zod";
6711
+ var SuccessPayload2 = z236.object({
6712
+ success: z236.literal(true)
6704
6713
  });
6705
- var DTODocumentationPageCreateActionOutputV2 = z235.object({
6706
- type: z235.literal("DocumentationPageCreate"),
6714
+ var DTODocumentationPageCreateActionOutputV2 = z236.object({
6715
+ type: z236.literal("DocumentationPageCreate"),
6707
6716
  output: SuccessPayload2
6708
6717
  });
6709
- var DTODocumentationPageUpdateActionOutputV2 = z235.object({
6710
- type: z235.literal("DocumentationPageUpdate"),
6718
+ var DTODocumentationPageUpdateActionOutputV2 = z236.object({
6719
+ type: z236.literal("DocumentationPageUpdate"),
6711
6720
  output: SuccessPayload2
6712
6721
  });
6713
- var DTODocumentationPageMoveActionOutputV2 = z235.object({
6714
- type: z235.literal("DocumentationPageMove"),
6722
+ var DTODocumentationPageMoveActionOutputV2 = z236.object({
6723
+ type: z236.literal("DocumentationPageMove"),
6715
6724
  output: SuccessPayload2
6716
6725
  });
6717
- var DTODocumentationPageDuplicateActionOutputV2 = z235.object({
6718
- type: z235.literal("DocumentationPageDuplicate"),
6726
+ var DTODocumentationPageDuplicateActionOutputV2 = z236.object({
6727
+ type: z236.literal("DocumentationPageDuplicate"),
6719
6728
  output: SuccessPayload2
6720
6729
  });
6721
- var DTODocumentationPageDeleteActionOutputV2 = z235.object({
6722
- type: z235.literal("DocumentationPageDelete"),
6730
+ var DTODocumentationPageDeleteActionOutputV2 = z236.object({
6731
+ type: z236.literal("DocumentationPageDelete"),
6723
6732
  output: SuccessPayload2
6724
6733
  });
6725
- var DTODocumentationPageRestoreActionOutput = z235.object({
6726
- type: z235.literal("DocumentationPageRestore"),
6734
+ var DTODocumentationPageRestoreActionOutput = z236.object({
6735
+ type: z236.literal("DocumentationPageRestore"),
6727
6736
  output: SuccessPayload2
6728
6737
  });
6729
- var DTODocumentationGroupRestoreActionOutput = z235.object({
6730
- type: z235.literal("DocumentationGroupRestore"),
6738
+ var DTODocumentationGroupRestoreActionOutput = z236.object({
6739
+ type: z236.literal("DocumentationGroupRestore"),
6731
6740
  output: SuccessPayload2
6732
6741
  });
6733
- var DTODocumentationPageApprovalStateChangeActionOutput = z235.object({
6734
- type: z235.literal("DocumentationPageApprovalStateChange"),
6742
+ var DTODocumentationPageApprovalStateChangeActionOutput = z236.object({
6743
+ type: z236.literal("DocumentationPageApprovalStateChange"),
6735
6744
  output: SuccessPayload2
6736
6745
  });
6737
- var DTODocumentationPageCreateActionInputV2 = z235.object({
6738
- type: z235.literal("DocumentationPageCreate"),
6746
+ var DTODocumentationPageCreateActionInputV2 = z236.object({
6747
+ type: z236.literal("DocumentationPageCreate"),
6739
6748
  input: DTOCreateDocumentationPageInputV2
6740
6749
  });
6741
- var DTODocumentationPageUpdateActionInputV2 = z235.object({
6742
- type: z235.literal("DocumentationPageUpdate"),
6750
+ var DTODocumentationPageUpdateActionInputV2 = z236.object({
6751
+ type: z236.literal("DocumentationPageUpdate"),
6743
6752
  input: DTOUpdateDocumentationPageInputV2
6744
6753
  });
6745
- var DTODocumentationPageMoveActionInputV2 = z235.object({
6746
- type: z235.literal("DocumentationPageMove"),
6754
+ var DTODocumentationPageMoveActionInputV2 = z236.object({
6755
+ type: z236.literal("DocumentationPageMove"),
6747
6756
  input: DTOMoveDocumentationPageInputV2
6748
6757
  });
6749
- var DTODocumentationPageDuplicateActionInputV2 = z235.object({
6750
- type: z235.literal("DocumentationPageDuplicate"),
6758
+ var DTODocumentationPageDuplicateActionInputV2 = z236.object({
6759
+ type: z236.literal("DocumentationPageDuplicate"),
6751
6760
  input: DTODuplicateDocumentationPageInputV2
6752
6761
  });
6753
- var DTODocumentationPageDeleteActionInputV2 = z235.object({
6754
- type: z235.literal("DocumentationPageDelete"),
6762
+ var DTODocumentationPageDeleteActionInputV2 = z236.object({
6763
+ type: z236.literal("DocumentationPageDelete"),
6755
6764
  input: DTODeleteDocumentationPageInputV2
6756
6765
  });
6757
- var DTODocumentationPageRestoreActionInput = z235.object({
6758
- type: z235.literal("DocumentationPageRestore"),
6766
+ var DTODocumentationPageRestoreActionInput = z236.object({
6767
+ type: z236.literal("DocumentationPageRestore"),
6759
6768
  input: DTORestoreDocumentationPageInput
6760
6769
  });
6761
- var DTODocumentationGroupRestoreActionInput = z235.object({
6762
- type: z235.literal("DocumentationGroupRestore"),
6770
+ var DTODocumentationGroupRestoreActionInput = z236.object({
6771
+ type: z236.literal("DocumentationGroupRestore"),
6763
6772
  input: DTORestoreDocumentationGroupInput
6764
6773
  });
6765
- var DTODocumentationPageApprovalStateChangeActionInput = z235.object({
6766
- type: z235.literal("DocumentationPageApprovalStateChange"),
6774
+ var DTODocumentationPageApprovalStateChangeActionInput = z236.object({
6775
+ type: z236.literal("DocumentationPageApprovalStateChange"),
6767
6776
  input: DTODocumentationPageApprovalStateChangeInput
6768
6777
  });
6769
6778
 
6770
6779
  // src/api/dto/elements/documentation/page-content.ts
6771
- import { z as z236 } from "zod";
6780
+ import { z as z237 } from "zod";
6772
6781
  var DTODocumentationPageContent = DocumentationPageContent;
6773
- var DTODocumentationPageContentGetResponse = z236.object({
6782
+ var DTODocumentationPageContentGetResponse = z237.object({
6774
6783
  pageContent: DTODocumentationPageContent
6775
6784
  });
6776
6785
 
6777
6786
  // src/api/dto/elements/documentation/page-v1.ts
6778
- import { z as z237 } from "zod";
6787
+ import { z as z238 } from "zod";
6779
6788
  var DocumentationPageV1DTO = DocumentationPageV1.omit({
6780
6789
  data: true,
6781
6790
  meta: true,
@@ -6783,63 +6792,63 @@ var DocumentationPageV1DTO = DocumentationPageV1.omit({
6783
6792
  sortOrder: true
6784
6793
  }).extend({
6785
6794
  configuration: DTODocumentationItemConfigurationV1,
6786
- blocks: z237.array(PageBlockV1),
6787
- title: z237.string(),
6788
- path: z237.string()
6795
+ blocks: z238.array(PageBlockV1),
6796
+ title: z238.string(),
6797
+ path: z238.string()
6789
6798
  });
6790
6799
 
6791
6800
  // src/api/dto/elements/documentation/structure.ts
6792
- import { z as z238 } from "zod";
6793
- var DTODocumentationStructureItemType = z238.enum(["Group", "Page"]);
6794
- var DTODocumentationStructureItemBase = z238.object({
6801
+ import { z as z239 } from "zod";
6802
+ var DTODocumentationStructureItemType = z239.enum(["Group", "Page"]);
6803
+ var DTODocumentationStructureItemBase = z239.object({
6795
6804
  type: DTODocumentationStructureItemType,
6796
- id: z238.string(),
6797
- designSystemVersionId: z238.string(),
6798
- shortPersistentId: z238.string(),
6799
- persistentId: z238.string(),
6800
- title: z238.string(),
6801
- createdAt: z238.coerce.date(),
6802
- updatedAt: z238.coerce.date()
6805
+ id: z239.string(),
6806
+ designSystemVersionId: z239.string(),
6807
+ shortPersistentId: z239.string(),
6808
+ persistentId: z239.string(),
6809
+ title: z239.string(),
6810
+ createdAt: z239.coerce.date(),
6811
+ updatedAt: z239.coerce.date()
6803
6812
  });
6804
6813
  var DTODocumentationStructureGroupItem = DTODocumentationStructureItemBase.extend({
6805
- type: z238.literal(DTODocumentationStructureItemType.enum.Group),
6806
- groupBehavior: z238.string(),
6807
- childrenIds: z238.string().array(),
6808
- isRoot: z238.boolean()
6814
+ type: z239.literal(DTODocumentationStructureItemType.enum.Group),
6815
+ groupBehavior: z239.string(),
6816
+ childrenIds: z239.string().array(),
6817
+ isRoot: z239.boolean()
6809
6818
  });
6810
6819
  var DTODocumentationStructurePageItem = DTODocumentationStructureItemBase.extend({
6811
- type: z238.literal(DTODocumentationStructureItemType.enum.Page),
6812
- path: z238.string()
6820
+ type: z239.literal(DTODocumentationStructureItemType.enum.Page),
6821
+ path: z239.string()
6813
6822
  });
6814
- var DTODocumentationStructureItem = z238.discriminatedUnion("type", [
6823
+ var DTODocumentationStructureItem = z239.discriminatedUnion("type", [
6815
6824
  DTODocumentationStructureGroupItem,
6816
6825
  DTODocumentationStructurePageItem
6817
6826
  ]);
6818
- var DTODocumentationStructure = z238.object({
6819
- items: z238.array(DTODocumentationStructureItem)
6827
+ var DTODocumentationStructure = z239.object({
6828
+ items: z239.array(DTODocumentationStructureItem)
6820
6829
  });
6821
6830
 
6822
6831
  // src/api/dto/elements/figma-nodes/figma-node.ts
6823
- import { z as z239 } from "zod";
6832
+ import { z as z240 } from "zod";
6824
6833
  var DTOFigmaNodeRenderFormat = FigmaNodeRenderFormat;
6825
- var DTOFigmaNodeOrigin = z239.object({
6826
- sourceId: z239.string(),
6827
- fileId: z239.string().optional(),
6828
- parentName: z239.string().optional()
6834
+ var DTOFigmaNodeOrigin = z240.object({
6835
+ sourceId: z240.string(),
6836
+ fileId: z240.string().optional(),
6837
+ parentName: z240.string().optional()
6829
6838
  });
6830
- var DTOFigmaNodeData = z239.object({
6839
+ var DTOFigmaNodeData = z240.object({
6831
6840
  // Id of the node in the Figma file
6832
- figmaNodeId: z239.string(),
6841
+ figmaNodeId: z240.string(),
6833
6842
  // Validity
6834
- isValid: z239.boolean(),
6843
+ isValid: z240.boolean(),
6835
6844
  // Asset data
6836
- assetId: z239.string(),
6837
- assetUrl: z239.string(),
6845
+ assetId: z240.string(),
6846
+ assetUrl: z240.string(),
6838
6847
  assetFormat: DTOFigmaNodeRenderFormat,
6839
6848
  // Asset metadata
6840
- assetScale: z239.number(),
6841
- assetWidth: z239.number().optional(),
6842
- assetHeight: z239.number().optional()
6849
+ assetScale: z240.number(),
6850
+ assetWidth: z240.number().optional(),
6851
+ assetHeight: z240.number().optional()
6843
6852
  });
6844
6853
  var DTOFigmaNode = FigmaNodeReference.omit({
6845
6854
  data: true,
@@ -6848,15 +6857,15 @@ var DTOFigmaNode = FigmaNodeReference.omit({
6848
6857
  data: DTOFigmaNodeData,
6849
6858
  origin: DTOFigmaNodeOrigin
6850
6859
  });
6851
- var DTOFigmaNodeRenderInput = z239.object({
6860
+ var DTOFigmaNodeRenderInput = z240.object({
6852
6861
  /**
6853
6862
  * Id of a design system's data source representing a linked Figma file
6854
6863
  */
6855
- sourceId: z239.string(),
6864
+ sourceId: z240.string(),
6856
6865
  /**
6857
6866
  * Id of a node within the Figma file
6858
6867
  */
6859
- figmaFileNodeId: z239.string(),
6868
+ figmaFileNodeId: z240.string(),
6860
6869
  /**
6861
6870
  * Format in which the node must be rendered, png by default.
6862
6871
  */
@@ -6864,97 +6873,97 @@ var DTOFigmaNodeRenderInput = z239.object({
6864
6873
  });
6865
6874
 
6866
6875
  // src/api/dto/elements/figma-nodes/node-actions-v2.ts
6867
- import { z as z240 } from "zod";
6868
- var DTOFigmaNodeRenderActionOutput = z240.object({
6869
- type: z240.literal("FigmaNodeRender"),
6870
- figmaNodes: z240.array(DTOFigmaNode)
6876
+ import { z as z241 } from "zod";
6877
+ var DTOFigmaNodeRenderActionOutput = z241.object({
6878
+ type: z241.literal("FigmaNodeRender"),
6879
+ figmaNodes: z241.array(DTOFigmaNode)
6871
6880
  });
6872
- var DTOFigmaNodeRenderActionInput = z240.object({
6873
- type: z240.literal("FigmaNodeRender"),
6881
+ var DTOFigmaNodeRenderActionInput = z241.object({
6882
+ type: z241.literal("FigmaNodeRender"),
6874
6883
  input: DTOFigmaNodeRenderInput.array()
6875
6884
  });
6876
6885
 
6877
6886
  // src/api/dto/elements/frame-node-structures/frame-node-structure.ts
6878
- import { z as z241 } from "zod";
6879
- var DTOFrameNodeStructure = z241.object({
6880
- id: z241.string(),
6881
- persistentId: z241.string(),
6882
- designSystemVersionId: z241.string(),
6887
+ import { z as z242 } from "zod";
6888
+ var DTOFrameNodeStructure = z242.object({
6889
+ id: z242.string(),
6890
+ persistentId: z242.string(),
6891
+ designSystemVersionId: z242.string(),
6883
6892
  origin: FigmaFileStructureOrigin,
6884
6893
  assetsInFile: FigmaFileStructureStatistics
6885
6894
  });
6886
- var DTOFrameNodeStructureListResponse = z241.object({
6895
+ var DTOFrameNodeStructureListResponse = z242.object({
6887
6896
  structures: DTOFrameNodeStructure.array()
6888
6897
  });
6889
6898
 
6890
6899
  // src/api/dto/elements/properties/property-definitions.ts
6891
- import { z as z242 } from "zod";
6900
+ import { z as z243 } from "zod";
6892
6901
  var CODE_NAME_REGEX2 = /^[a-zA-Z_$][a-zA-Z_$0-9]{1,99}$/;
6893
- var DTOElementPropertyDefinitionOption = z242.object({
6894
- id: z242.string(),
6895
- name: z242.string(),
6902
+ var DTOElementPropertyDefinitionOption = z243.object({
6903
+ id: z243.string(),
6904
+ name: z243.string(),
6896
6905
  backgroundColor: DTOColorTokenInlineData.optional()
6897
6906
  });
6898
- var DTOElementPropertyDefinition = z242.object({
6899
- id: z242.string(),
6900
- designSystemVersionId: z242.string(),
6907
+ var DTOElementPropertyDefinition = z243.object({
6908
+ id: z243.string(),
6909
+ designSystemVersionId: z243.string(),
6901
6910
  meta: DTOObjectMeta,
6902
- persistentId: z242.string(),
6911
+ persistentId: z243.string(),
6903
6912
  type: ElementPropertyTypeSchema,
6904
6913
  targetElementType: ElementPropertyTargetType,
6905
- codeName: z242.string().regex(CODE_NAME_REGEX2),
6906
- options: nullishToOptional(z242.array(DTOElementPropertyDefinitionOption)),
6914
+ codeName: z243.string().regex(CODE_NAME_REGEX2),
6915
+ options: nullishToOptional(z243.array(DTOElementPropertyDefinitionOption)),
6907
6916
  linkElementType: nullishToOptional(ElementPropertyLinkType),
6908
- isImmutable: z242.boolean(),
6917
+ isImmutable: z243.boolean(),
6909
6918
  immutablePropertyType: ElementPropertyImmutableType.optional()
6910
6919
  });
6911
- var DTOElementPropertyDefinitionListResponse = z242.object({
6912
- definitions: z242.array(DTOElementPropertyDefinition)
6920
+ var DTOElementPropertyDefinitionListResponse = z243.object({
6921
+ definitions: z243.array(DTOElementPropertyDefinition)
6913
6922
  });
6914
- var DTOElementPropertyDefinitionResponse = z242.object({
6923
+ var DTOElementPropertyDefinitionResponse = z243.object({
6915
6924
  definition: DTOElementPropertyDefinition
6916
6925
  });
6917
- var DTOElementPropertyDefinitionCreatePayload = z242.object({
6926
+ var DTOElementPropertyDefinitionCreatePayload = z243.object({
6918
6927
  meta: DTOObjectMeta,
6919
- persistentId: z242.string(),
6928
+ persistentId: z243.string(),
6920
6929
  type: ElementPropertyTypeSchema,
6921
6930
  targetElementType: ElementPropertyTargetType,
6922
- codeName: z242.string().regex(CODE_NAME_REGEX2),
6923
- options: nullishToOptional(z242.array(DTOElementPropertyDefinitionOption)),
6931
+ codeName: z243.string().regex(CODE_NAME_REGEX2),
6932
+ options: nullishToOptional(z243.array(DTOElementPropertyDefinitionOption)),
6924
6933
  linkElementType: nullishToOptional(ElementPropertyLinkType),
6925
- columnWidth: z242.number().max(1024).optional()
6934
+ columnWidth: z243.number().max(1024).optional()
6926
6935
  });
6927
- var DTOElementPropertyDefinitionUpdatePayload = z242.object({
6936
+ var DTOElementPropertyDefinitionUpdatePayload = z243.object({
6928
6937
  meta: DTOObjectMeta.optional(),
6929
- codeName: z242.string().regex(CODE_NAME_REGEX2).optional(),
6930
- options: z242.array(DTOElementPropertyDefinitionOption).optional()
6938
+ codeName: z243.string().regex(CODE_NAME_REGEX2).optional(),
6939
+ options: z243.array(DTOElementPropertyDefinitionOption).optional()
6931
6940
  });
6932
6941
 
6933
6942
  // src/api/dto/elements/properties/property-values.ts
6934
- import { z as z243 } from "zod";
6935
- var DTOElementPropertyValue = z243.object({
6936
- id: z243.string(),
6937
- designSystemVersionId: z243.string(),
6938
- definitionId: z243.string(),
6939
- targetElementId: z243.string(),
6940
- value: z243.union([z243.string(), z243.number(), z243.boolean()]).optional(),
6941
- valuePreview: z243.string().optional()
6942
- });
6943
- var DTOElementPropertyValueListResponse = z243.object({
6944
- values: z243.array(DTOElementPropertyValue)
6945
- });
6946
- var DTOElementPropertyValueResponse = z243.object({
6943
+ import { z as z244 } from "zod";
6944
+ var DTOElementPropertyValue = z244.object({
6945
+ id: z244.string(),
6946
+ designSystemVersionId: z244.string(),
6947
+ definitionId: z244.string(),
6948
+ targetElementId: z244.string(),
6949
+ value: z244.union([z244.string(), z244.number(), z244.boolean()]).optional(),
6950
+ valuePreview: z244.string().optional()
6951
+ });
6952
+ var DTOElementPropertyValueListResponse = z244.object({
6953
+ values: z244.array(DTOElementPropertyValue)
6954
+ });
6955
+ var DTOElementPropertyValueResponse = z244.object({
6947
6956
  value: DTOElementPropertyValue
6948
6957
  });
6949
- var DTOElementPropertyValueUpsertPaylod = z243.object({
6950
- definitionId: z243.string(),
6951
- targetElementId: z243.string(),
6952
- value: z243.string().or(z243.number()).or(z243.boolean())
6958
+ var DTOElementPropertyValueUpsertPaylod = z244.object({
6959
+ definitionId: z244.string(),
6960
+ targetElementId: z244.string(),
6961
+ value: z244.string().or(z244.number()).or(z244.boolean())
6953
6962
  });
6954
6963
 
6955
6964
  // src/api/dto/elements/elements-action-v2.ts
6956
- import { z as z244 } from "zod";
6957
- var DTOElementActionOutput = z244.discriminatedUnion("type", [
6965
+ import { z as z245 } from "zod";
6966
+ var DTOElementActionOutput = z245.discriminatedUnion("type", [
6958
6967
  // Documentation pages
6959
6968
  DTODocumentationPageCreateActionOutputV2,
6960
6969
  DTODocumentationPageUpdateActionOutputV2,
@@ -6977,7 +6986,7 @@ var DTOElementActionOutput = z244.discriminatedUnion("type", [
6977
6986
  // Approvals
6978
6987
  DTODocumentationPageApprovalStateChangeActionOutput
6979
6988
  ]);
6980
- var DTOElementActionInput = z244.discriminatedUnion("type", [
6989
+ var DTOElementActionInput = z245.discriminatedUnion("type", [
6981
6990
  // Documentation pages
6982
6991
  DTODocumentationPageCreateActionInputV2,
6983
6992
  DTODocumentationPageUpdateActionInputV2,
@@ -7002,80 +7011,80 @@ var DTOElementActionInput = z244.discriminatedUnion("type", [
7002
7011
  ]);
7003
7012
 
7004
7013
  // src/api/dto/elements/get-elements-v2.ts
7005
- import { z as z245 } from "zod";
7006
- var DTOElementsGetTypeFilter = z245.enum(["FigmaNode"]);
7007
- var DTOElementsGetQuerySchema = z245.object({
7008
- types: z245.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
7014
+ import { z as z246 } from "zod";
7015
+ var DTOElementsGetTypeFilter = z246.enum(["FigmaNode"]);
7016
+ var DTOElementsGetQuerySchema = z246.object({
7017
+ types: z246.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
7009
7018
  });
7010
- var DTOElementsGetOutput = z245.object({
7011
- figmaNodes: z245.array(DTOFigmaNode).optional()
7019
+ var DTOElementsGetOutput = z246.object({
7020
+ figmaNodes: z246.array(DTOFigmaNode).optional()
7012
7021
  });
7013
7022
 
7014
7023
  // src/api/dto/figma-components/assets/download.ts
7015
- import { z as z246 } from "zod";
7016
- var DTOAssetRenderConfiguration = z246.object({
7017
- prefix: z246.string().optional(),
7018
- suffix: z246.string().optional(),
7019
- scale: z246.enum(["x1", "x2", "x3", "x4"]),
7020
- format: z246.enum(["png", "pdf", "svg"])
7021
- });
7022
- var DTORenderedAssetFile = z246.object({
7023
- assetId: z246.string(),
7024
- fileName: z246.string(),
7025
- sourceUrl: z246.string(),
7024
+ import { z as z247 } from "zod";
7025
+ var DTOAssetRenderConfiguration = z247.object({
7026
+ prefix: z247.string().optional(),
7027
+ suffix: z247.string().optional(),
7028
+ scale: z247.enum(["x1", "x2", "x3", "x4"]),
7029
+ format: z247.enum(["png", "pdf", "svg"])
7030
+ });
7031
+ var DTORenderedAssetFile = z247.object({
7032
+ assetId: z247.string(),
7033
+ fileName: z247.string(),
7034
+ sourceUrl: z247.string(),
7026
7035
  settings: DTOAssetRenderConfiguration,
7027
- originalName: z246.string()
7036
+ originalName: z247.string()
7028
7037
  });
7029
- var DTODownloadAssetsRequest = z246.object({
7030
- persistentIds: z246.array(z246.string().uuid()).optional(),
7038
+ var DTODownloadAssetsRequest = z247.object({
7039
+ persistentIds: z247.array(z247.string().uuid()).optional(),
7031
7040
  settings: DTOAssetRenderConfiguration.array()
7032
7041
  });
7033
- var DTODownloadAssetsResponse = z246.object({
7042
+ var DTODownloadAssetsResponse = z247.object({
7034
7043
  items: DTORenderedAssetFile.array()
7035
7044
  });
7036
7045
 
7037
7046
  // src/api/dto/liveblocks/auth-response.ts
7038
- import { z as z247 } from "zod";
7039
- var DTOLiveblocksAuthResponse = z247.object({
7040
- token: z247.string()
7047
+ import { z as z248 } from "zod";
7048
+ var DTOLiveblocksAuthResponse = z248.object({
7049
+ token: z248.string()
7041
7050
  });
7042
7051
 
7043
7052
  // src/api/dto/themes/override.ts
7044
- import { z as z248 } from "zod";
7053
+ import { z as z249 } from "zod";
7045
7054
  var DTOThemeOverride = DesignTokenTypedData.and(
7046
- z248.object({
7047
- tokenPersistentId: z248.string(),
7055
+ z249.object({
7056
+ tokenPersistentId: z249.string(),
7048
7057
  origin: ThemeOverrideOrigin.optional()
7049
7058
  })
7050
7059
  );
7051
7060
  var DTOThemeOverrideCreatePayload = DesignTokenTypedData.and(
7052
- z248.object({
7053
- tokenPersistentId: z248.string()
7061
+ z249.object({
7062
+ tokenPersistentId: z249.string()
7054
7063
  })
7055
7064
  );
7056
7065
 
7057
7066
  // src/api/dto/themes/theme.ts
7058
- import { z as z249 } from "zod";
7059
- var DTOTheme = z249.object({
7060
- id: z249.string(),
7061
- persistentId: z249.string(),
7062
- designSystemVersionId: z249.string(),
7063
- brandId: z249.string(),
7067
+ import { z as z250 } from "zod";
7068
+ var DTOTheme = z250.object({
7069
+ id: z250.string(),
7070
+ persistentId: z250.string(),
7071
+ designSystemVersionId: z250.string(),
7072
+ brandId: z250.string(),
7064
7073
  meta: ObjectMeta,
7065
- codeName: z249.string(),
7074
+ codeName: z250.string(),
7066
7075
  overrides: DTOThemeOverride.array()
7067
7076
  });
7068
- var DTOThemeResponse = z249.object({
7077
+ var DTOThemeResponse = z250.object({
7069
7078
  theme: DTOTheme
7070
7079
  });
7071
- var DTOThemeListResponse = z249.object({
7080
+ var DTOThemeListResponse = z250.object({
7072
7081
  themes: DTOTheme.array()
7073
7082
  });
7074
- var DTOThemeCreatePayload = z249.object({
7083
+ var DTOThemeCreatePayload = z250.object({
7075
7084
  meta: ObjectMeta,
7076
- persistentId: z249.string(),
7077
- brandId: z249.string(),
7078
- codeName: z249.string(),
7085
+ persistentId: z250.string(),
7086
+ brandId: z250.string(),
7087
+ codeName: z250.string(),
7079
7088
  overrides: DTOThemeOverride.array()
7080
7089
  });
7081
7090
 
@@ -7206,7 +7215,7 @@ var CodegenEndpoint = class {
7206
7215
  };
7207
7216
 
7208
7217
  // src/api/endpoints/design-system/versions/brands.ts
7209
- import { z as z250 } from "zod";
7218
+ import { z as z251 } from "zod";
7210
7219
  var BrandsEndpoint = class {
7211
7220
  constructor(requestExecutor) {
7212
7221
  this.requestExecutor = requestExecutor;
@@ -7240,7 +7249,7 @@ var BrandsEndpoint = class {
7240
7249
  });
7241
7250
  }
7242
7251
  delete(dsId, vId, brandId) {
7243
- return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/brands/${brandId}`, z250.any(), {
7252
+ return this.requestExecutor.json(`/design-systems/${dsId}/versions/${vId}/brands/${brandId}`, z251.any(), {
7244
7253
  method: "DELETE"
7245
7254
  });
7246
7255
  }
@@ -7394,7 +7403,7 @@ var ImportJobsEndpoint = class {
7394
7403
  };
7395
7404
 
7396
7405
  // src/api/endpoints/design-system/versions/overrides.ts
7397
- import { z as z251 } from "zod";
7406
+ import { z as z252 } from "zod";
7398
7407
  var OverridesEndpoint = class {
7399
7408
  constructor(requestExecutor) {
7400
7409
  this.requestExecutor = requestExecutor;
@@ -7402,7 +7411,7 @@ var OverridesEndpoint = class {
7402
7411
  create(dsId, versionId, themeId, body) {
7403
7412
  return this.requestExecutor.json(
7404
7413
  `/design-systems/${dsId}/versions/${versionId}/themes/${themeId}/overrides`,
7405
- z251.any(),
7414
+ z252.any(),
7406
7415
  {
7407
7416
  method: "POST",
7408
7417
  body
@@ -7412,7 +7421,7 @@ var OverridesEndpoint = class {
7412
7421
  };
7413
7422
 
7414
7423
  // src/api/endpoints/design-system/versions/property-definitions.ts
7415
- import { z as z252 } from "zod";
7424
+ import { z as z253 } from "zod";
7416
7425
  var ElementPropertyDefinitionsEndpoint = class {
7417
7426
  constructor(requestExecutor) {
7418
7427
  this.requestExecutor = requestExecutor;
@@ -7440,7 +7449,7 @@ var ElementPropertyDefinitionsEndpoint = class {
7440
7449
  delete(designSystemId, versionId, defId) {
7441
7450
  return this.requestExecutor.json(
7442
7451
  `/design-systems/${designSystemId}/versions/${versionId}/element-properties/definitions/${defId}`,
7443
- z252.any(),
7452
+ z253.any(),
7444
7453
  { method: "DELETE" }
7445
7454
  );
7446
7455
  }
@@ -7479,7 +7488,7 @@ var VersionStatsEndpoint = class {
7479
7488
  };
7480
7489
 
7481
7490
  // src/api/endpoints/design-system/versions/themes.ts
7482
- import { z as z253 } from "zod";
7491
+ import { z as z254 } from "zod";
7483
7492
  var ThemesEndpoint = class {
7484
7493
  constructor(requestExecutor) {
7485
7494
  this.requestExecutor = requestExecutor;
@@ -7502,7 +7511,7 @@ var ThemesEndpoint = class {
7502
7511
  });
7503
7512
  }
7504
7513
  delete(dsId, versionId, themeId) {
7505
- return this.requestExecutor.json(`/design-systems/${dsId}/versions/${versionId}/themes/${themeId}`, z253.any(), {
7514
+ return this.requestExecutor.json(`/design-systems/${dsId}/versions/${versionId}/themes/${themeId}`, z254.any(), {
7506
7515
  method: "DELETE"
7507
7516
  });
7508
7517
  }
@@ -7649,7 +7658,7 @@ var DesignSystemContactsEndpoint = class {
7649
7658
  };
7650
7659
 
7651
7660
  // src/api/endpoints/design-system/design-systems.ts
7652
- import { z as z255 } from "zod";
7661
+ import { z as z256 } from "zod";
7653
7662
 
7654
7663
  // src/api/endpoints/design-system/members.ts
7655
7664
  var DesignSystemMembersEndpoint = class {
@@ -7670,7 +7679,7 @@ var DesignSystemMembersEndpoint = class {
7670
7679
  };
7671
7680
 
7672
7681
  // src/api/endpoints/design-system/sources.ts
7673
- import { z as z254 } from "zod";
7682
+ import { z as z255 } from "zod";
7674
7683
  var DesignSystemSourcesEndpoint = class {
7675
7684
  constructor(requestExecutor) {
7676
7685
  this.requestExecutor = requestExecutor;
@@ -7685,7 +7694,7 @@ var DesignSystemSourcesEndpoint = class {
7685
7694
  return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourcesListResponse);
7686
7695
  }
7687
7696
  delete(dsId, sourceId) {
7688
- return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, z254.any(), { method: "DELETE" });
7697
+ return this.requestExecutor.json(`/design-systems/${dsId}/sources/${sourceId}`, z255.any(), { method: "DELETE" });
7689
7698
  }
7690
7699
  figmaImport(dsId, payload) {
7691
7700
  return this.requestExecutor.json(`/design-systems/${dsId}/versions/head/cloud-import`, DTOImportJobResponse, {
@@ -7720,7 +7729,7 @@ var DesignSystemsEndpoint = class {
7720
7729
  return this.requestExecutor.json(`/design-systems/${dsId}`, DTODesignSystemResponse);
7721
7730
  }
7722
7731
  delete(dsId) {
7723
- return this.requestExecutor.json(`/design-systems/${dsId}`, z255.any(), { method: "DELETE" });
7732
+ return this.requestExecutor.json(`/design-systems/${dsId}`, z256.any(), { method: "DELETE" });
7724
7733
  }
7725
7734
  update(dsId, body) {
7726
7735
  return this.requestExecutor.json(`/design-systems/${dsId}`, DTODesignSystemResponse, {
@@ -7764,7 +7773,7 @@ var WorkspaceInvitationsEndpoint = class {
7764
7773
  };
7765
7774
 
7766
7775
  // src/api/endpoints/workspaces/workspace-members.ts
7767
- import { z as z256 } from "zod";
7776
+ import { z as z257 } from "zod";
7768
7777
  var WorkspaceMembersEndpoint = class {
7769
7778
  constructor(requestExecutor) {
7770
7779
  this.requestExecutor = requestExecutor;
@@ -7781,7 +7790,7 @@ var WorkspaceMembersEndpoint = class {
7781
7790
  });
7782
7791
  }
7783
7792
  invite(workspaceId, body) {
7784
- return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z256.any(), { method: "POST", body });
7793
+ return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z257.any(), { method: "POST", body });
7785
7794
  }
7786
7795
  delete(workspaceId, userId) {
7787
7796
  return this.requestExecutor.json(`/workspaces/${workspaceId}/members/${userId}`, DTOWorkspaceResponse, {
@@ -7791,7 +7800,7 @@ var WorkspaceMembersEndpoint = class {
7791
7800
  };
7792
7801
 
7793
7802
  // src/api/endpoints/workspaces/workspaces.ts
7794
- import { z as z257 } from "zod";
7803
+ import { z as z258 } from "zod";
7795
7804
  var WorkspacesEndpoint = class {
7796
7805
  constructor(requestExecutor) {
7797
7806
  this.requestExecutor = requestExecutor;
@@ -7814,10 +7823,10 @@ var WorkspacesEndpoint = class {
7814
7823
  return this.requestExecutor.json(`/workspaces/${workspaceId}`, DTOWorkspaceResponse, { method: "GET" });
7815
7824
  }
7816
7825
  delete(workspaceId) {
7817
- return this.requestExecutor.json(`/workspaces/${workspaceId}`, z257.any(), { method: "DELETE" });
7826
+ return this.requestExecutor.json(`/workspaces/${workspaceId}`, z258.any(), { method: "DELETE" });
7818
7827
  }
7819
7828
  subscription(workspaceId) {
7820
- return this.requestExecutor.json(`/workspaces/${workspaceId}/subscription`, z257.any(), { method: "GET" });
7829
+ return this.requestExecutor.json(`/workspaces/${workspaceId}/subscription`, z258.any(), { method: "GET" });
7821
7830
  }
7822
7831
  transferOwnership(workspaceId, body) {
7823
7832
  return this.requestExecutor.json(`/workspaces/${workspaceId}/ownership`, DTOWorkspaceResponse, {
@@ -7904,9 +7913,9 @@ ${bodyText}`,
7904
7913
 
7905
7914
  // src/api/transport/request-executor.ts
7906
7915
  import fetch from "node-fetch";
7907
- import { z as z258 } from "zod";
7908
- var ResponseWrapper = z258.object({
7909
- result: z258.record(z258.any())
7916
+ import { z as z259 } from "zod";
7917
+ var ResponseWrapper = z259.object({
7918
+ result: z259.record(z259.any())
7910
7919
  });
7911
7920
  var RequestExecutor = class {
7912
7921
  constructor(testServerConfig) {
@@ -7981,7 +7990,7 @@ var SupernovaApiClient = class {
7981
7990
  };
7982
7991
 
7983
7992
  // src/yjs/design-system-content/documentation-hierarchy.ts
7984
- import { z as z259 } from "zod";
7993
+ import { z as z260 } from "zod";
7985
7994
 
7986
7995
  // src/yjs/version-room/base.ts
7987
7996
  var VersionRoomBaseYDoc = class {
@@ -8511,24 +8520,24 @@ var FrontendVersionRoomYDoc = class {
8511
8520
  };
8512
8521
 
8513
8522
  // src/yjs/design-system-content/documentation-hierarchy.ts
8514
- var DocumentationHierarchySettings = z259.object({
8515
- routingVersion: z259.string(),
8516
- isDraftFeatureAdopted: z259.boolean(),
8517
- isApprovalFeatureEnabled: z259.boolean(),
8518
- approvalRequiredForPublishing: z259.boolean()
8523
+ var DocumentationHierarchySettings = z260.object({
8524
+ routingVersion: z260.string(),
8525
+ isDraftFeatureAdopted: z260.boolean(),
8526
+ isApprovalFeatureEnabled: z260.boolean(),
8527
+ approvalRequiredForPublishing: z260.boolean()
8519
8528
  });
8520
8529
  function yjsToDocumentationHierarchy(doc) {
8521
8530
  return new FrontendVersionRoomYDoc(doc).getDocumentationHierarchy();
8522
8531
  }
8523
8532
 
8524
8533
  // src/yjs/design-system-content/item-configuration.ts
8525
- import { z as z260 } from "zod";
8526
- var DTODocumentationPageRoomHeaderData = z260.object({
8527
- title: z260.string(),
8534
+ import { z as z261 } from "zod";
8535
+ var DTODocumentationPageRoomHeaderData = z261.object({
8536
+ title: z261.string(),
8528
8537
  configuration: DTODocumentationItemConfigurationV2
8529
8538
  });
8530
- var DTODocumentationPageRoomHeaderDataUpdate = z260.object({
8531
- title: z260.string().optional(),
8539
+ var DTODocumentationPageRoomHeaderDataUpdate = z261.object({
8540
+ title: z261.string().optional(),
8532
8541
  configuration: DTODocumentationItemConfigurationV2.omit({ header: true }).extend({ header: DocumentationItemHeaderV2.partial() }).optional()
8533
8542
  });
8534
8543
  function itemConfigurationToYjs(yDoc, item) {
@@ -8579,7 +8588,7 @@ function yjsToItemConfiguration(yDoc) {
8579
8588
  header: rawHeader
8580
8589
  };
8581
8590
  return {
8582
- title: z260.string().parse(title),
8591
+ title: z261.string().parse(title),
8583
8592
  configuration: DTODocumentationItemConfigurationV2.parse(rawConfig)
8584
8593
  };
8585
8594
  }
@@ -8589,9 +8598,9 @@ var PageBlockEditorModel = PageBlockEditorModelV2;
8589
8598
  var PageSectionEditorModel = PageSectionEditorModelV2;
8590
8599
 
8591
8600
  // src/yjs/docs-editor/model/page.ts
8592
- import { z as z261 } from "zod";
8593
- var DocumentationPageEditorModel = z261.object({
8594
- blocks: z261.array(DocumentationPageContentItem)
8601
+ import { z as z262 } from "zod";
8602
+ var DocumentationPageEditorModel = z262.object({
8603
+ blocks: z262.array(DocumentationPageContentItem)
8595
8604
  });
8596
8605
 
8597
8606
  // src/yjs/docs-editor/prosemirror/inner-editor-schema.ts
@@ -12112,7 +12121,7 @@ var blocks = [
12112
12121
 
12113
12122
  // src/yjs/docs-editor/prosemirror-to-blocks.ts
12114
12123
  import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
12115
- import { z as z262 } from "zod";
12124
+ import { z as z263 } from "zod";
12116
12125
  function yDocToPage(yDoc, definitions) {
12117
12126
  return yXmlFragmentToPage(yDoc.getXmlFragment("default"), definitions);
12118
12127
  }
@@ -12192,7 +12201,7 @@ function prosemirrorNodeToSectionItem(prosemirrorNode, definitionsMap) {
12192
12201
  return null;
12193
12202
  return {
12194
12203
  id,
12195
- title: getProsemirrorAttribute(prosemirrorNode, "title", z262.string()) ?? "",
12204
+ title: getProsemirrorAttribute(prosemirrorNode, "title", z263.string()) ?? "",
12196
12205
  columns: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItemColumn").map((c) => prosemirrorNodeToSectionColumns(c, definitionsMap)).filter(nonNullFilter)
12197
12206
  };
12198
12207
  }
@@ -12227,7 +12236,7 @@ function internalProsemirrorNodesToBlocks(prosemirrorNodes, definitionsMap, dept
12227
12236
  });
12228
12237
  }
12229
12238
  function internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap, depth) {
12230
- const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z262.string());
12239
+ const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z263.string());
12231
12240
  if (!definitionId) {
12232
12241
  console.warn(`definitionId on ${prosemirrorNode.type} is required to be interpreted as a block, skipping node`);
12233
12242
  return [];
@@ -12269,7 +12278,7 @@ function parseAsRichText(prosemirrorNode, definition, property) {
12269
12278
  if (!id)
12270
12279
  return null;
12271
12280
  const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
12272
- const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z262.string().optional()));
12281
+ const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z263.string().optional()));
12273
12282
  return {
12274
12283
  id,
12275
12284
  type: "Block",
@@ -12397,10 +12406,10 @@ function parseRichTextAttribute(mark) {
12397
12406
  return null;
12398
12407
  }
12399
12408
  function parseProsemirrorLink(mark) {
12400
- const href = getProsemirrorAttribute(mark, "href", z262.string().optional());
12409
+ const href = getProsemirrorAttribute(mark, "href", z263.string().optional());
12401
12410
  if (!href)
12402
12411
  return null;
12403
- const target = getProsemirrorAttribute(mark, "target", z262.string().optional());
12412
+ const target = getProsemirrorAttribute(mark, "target", z263.string().optional());
12404
12413
  const openInNewTab = target === "_blank";
12405
12414
  if (href.startsWith("@")) {
12406
12415
  return {
@@ -12419,10 +12428,10 @@ function parseProsemirrorLink(mark) {
12419
12428
  }
12420
12429
  }
12421
12430
  function parseProsemirrorCommentHighlight(mark) {
12422
- const highlightId = getProsemirrorAttribute(mark, "highlightId", z262.string().optional());
12431
+ const highlightId = getProsemirrorAttribute(mark, "highlightId", z263.string().optional());
12423
12432
  if (!highlightId)
12424
12433
  return null;
12425
- const isResolved = getProsemirrorAttribute(mark, "resolved", z262.boolean().optional()) ?? false;
12434
+ const isResolved = getProsemirrorAttribute(mark, "resolved", z263.boolean().optional()) ?? false;
12426
12435
  return {
12427
12436
  type: "Comment",
12428
12437
  commentHighlightId: highlightId,
@@ -12434,7 +12443,7 @@ function parseAsTable(prosemirrorNode, definition, property) {
12434
12443
  if (!id)
12435
12444
  return null;
12436
12445
  const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
12437
- const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z262.boolean().optional()) !== false;
12446
+ const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z263.boolean().optional()) !== false;
12438
12447
  const tableChild = prosemirrorNode.content?.find((c) => c.type === "table");
12439
12448
  if (!tableChild) {
12440
12449
  return emptyTable(id, variantId, 0);
@@ -12481,9 +12490,9 @@ function parseAsTableCell(prosemirrorNode) {
12481
12490
  const id = getProsemirrorBlockId(prosemirrorNode);
12482
12491
  if (!id)
12483
12492
  return null;
12484
- const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z262.string().optional());
12493
+ const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z263.string().optional());
12485
12494
  let columnWidth;
12486
- const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z262.array(z262.number()).nullish());
12495
+ const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z263.array(z263.number()).nullish());
12487
12496
  if (columnWidthArray) {
12488
12497
  columnWidth = roundDimension(columnWidthArray[0]);
12489
12498
  }
@@ -12521,7 +12530,7 @@ function parseAsTableNode(prosemirrorNode) {
12521
12530
  value: parseRichText(prosemirrorNode.content ?? [])
12522
12531
  };
12523
12532
  case "image":
12524
- const items = getProsemirrorAttribute(prosemirrorNode, "items", z262.string());
12533
+ const items = getProsemirrorAttribute(prosemirrorNode, "items", z263.string());
12525
12534
  if (!items)
12526
12535
  return null;
12527
12536
  const parsedItems = PageBlockItemV2.array().safeParse(JSON.parse(items));
@@ -12641,7 +12650,7 @@ function definitionExpectsPlaceholderItem(definition) {
12641
12650
  );
12642
12651
  }
12643
12652
  function parseBlockItems(prosemirrorNode, definition) {
12644
- const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z262.string());
12653
+ const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z263.string());
12645
12654
  if (!itemsString)
12646
12655
  return null;
12647
12656
  const itemsJson = JSON.parse(itemsString);
@@ -12653,18 +12662,18 @@ function parseBlockItems(prosemirrorNode, definition) {
12653
12662
  }
12654
12663
  function parseAppearance(prosemirrorNode) {
12655
12664
  let appearance = {};
12656
- const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z262.string().optional());
12665
+ const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z263.string().optional());
12657
12666
  if (rawAppearanceString) {
12658
12667
  const parsedAppearance = PageBlockAppearanceV2.safeParse(JSON.parse(rawAppearanceString));
12659
12668
  if (parsedAppearance.success) {
12660
12669
  appearance = parsedAppearance.data;
12661
12670
  }
12662
12671
  }
12663
- const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z262.number().optional());
12672
+ const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z263.number().optional());
12664
12673
  if (columns) {
12665
12674
  appearance.numberOfColumns = columns;
12666
12675
  }
12667
- const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z262.string().optional());
12676
+ const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z263.string().optional());
12668
12677
  if (backgroundColor) {
12669
12678
  const parsedColor = PageBlockColorV2.safeParse(JSON.parse(backgroundColor));
12670
12679
  if (parsedColor.success) {
@@ -12759,13 +12768,13 @@ function valueSchemaForPropertyType(type) {
12759
12768
  }
12760
12769
  }
12761
12770
  function getProsemirrorBlockId(prosemirrorNode) {
12762
- const id = getProsemirrorAttribute(prosemirrorNode, "id", z262.string());
12771
+ const id = getProsemirrorAttribute(prosemirrorNode, "id", z263.string());
12763
12772
  if (!id)
12764
12773
  console.warn(`Prosemirror attribute "id" on ${prosemirrorNode.type} is required`);
12765
12774
  return id;
12766
12775
  }
12767
12776
  function getProsemirrorBlockVariantId(prosemirrorNode) {
12768
- return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z262.string()));
12777
+ return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z263.string()));
12769
12778
  }
12770
12779
  function getProsemirrorAttribute(prosemirrorNode, attributeName, validationSchema) {
12771
12780
  const parsedAttr = validationSchema.safeParse(prosemirrorNode.attrs?.[attributeName]);