@supernova-studio/client 0.54.33 → 0.54.35

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 (8) hide show
  1. package/dist/index.d.mts +6 -3
  2. package/dist/index.d.ts +6 -3
  3. package/dist/index.js +37 -18
  4. package/dist/index.js.map +1 -1
  5. package/dist/index.mjs +920 -901
  6. package/dist/index.mjs.map +1 -1
  7. package/package.json +1 -1
  8. package/src/api/transport/request-executor-error.ts +36 -5
package/dist/index.mjs CHANGED
@@ -162,23 +162,24 @@ import { z as z153 } from "zod";
162
162
  import { z as z152 } from "zod";
163
163
  import { z as z151 } from "zod";
164
164
  import { z as z154 } from "zod";
165
- import { z as z157 } from "zod";
166
165
  import { z as z155 } from "zod";
167
- import { z as z156 } from "zod";
168
166
  import { z as z158 } from "zod";
167
+ import { z as z156 } from "zod";
168
+ import { z as z157 } from "zod";
169
169
  import { z as z159 } from "zod";
170
170
  import { z as z160 } from "zod";
171
171
  import { z as z161 } from "zod";
172
172
  import { z as z162 } from "zod";
173
173
  import { z as z163 } from "zod";
174
- import { z as z165 } from "zod";
175
174
  import { z as z164 } from "zod";
176
175
  import { z as z166 } from "zod";
176
+ import { z as z165 } from "zod";
177
177
  import { z as z167 } from "zod";
178
178
  import { z as z168 } from "zod";
179
179
  import { z as z169 } from "zod";
180
180
  import { z as z170 } from "zod";
181
181
  import { z as z171 } from "zod";
182
+ import { z as z172 } from "zod";
182
183
  var __defProp2 = Object.defineProperty;
183
184
  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
184
185
  var __publicField2 = (obj, key, value) => {
@@ -3666,20 +3667,7 @@ var HANDLE_MIN_LENGTH = 2;
3666
3667
  var HANDLE_MAX_LENGTH = 64;
3667
3668
  var CreateWorkspaceInput = z120.object({
3668
3669
  name: z120.string().min(WORKSPACE_NAME_MIN_LENGTH).max(WORKSPACE_NAME_MAX_LENGTH).trim(),
3669
- product: ProductCodeSchema,
3670
- priceId: z120.string(),
3671
- billingEmail: z120.string().email().optional(),
3672
- handle: z120.string().regex(slugRegex).min(HANDLE_MIN_LENGTH).max(HANDLE_MAX_LENGTH).refine((value) => value?.length > 0).optional(),
3673
- invites: UserInvites.optional(),
3674
- promoCode: z120.string().optional(),
3675
- status: InternalStatusSchema.optional(),
3676
- planInterval: BillingIntervalSchema.optional(),
3677
- seats: z120.number().optional(),
3678
- seatLimit: z120.number().optional(),
3679
- card: CardSchema.optional(),
3680
- sso: SsoProvider.optional(),
3681
- npmRegistrySettings: NpmRegistryConfig.optional(),
3682
- ipWhitelist: WorkspaceIpSettings.optional()
3670
+ handle: z120.string().regex(slugRegex).min(HANDLE_MIN_LENGTH).max(HANDLE_MAX_LENGTH).refine((value) => value?.length > 0).optional()
3683
3671
  });
3684
3672
  var WorkspaceInvitation = z121.object({
3685
3673
  id: z121.string(),
@@ -4331,45 +4319,54 @@ var UserSession = z154.object({
4331
4319
  session: Session,
4332
4320
  user: User.nullable()
4333
4321
  });
4334
- var EventDataSourceImported = z155.object({
4335
- type: z155.literal("DataSourceImported"),
4336
- workspaceId: z155.string(),
4337
- designSystemId: z155.string()
4322
+ var DesignSystemInviteEmailRecipient = z155.object({
4323
+ email: z155.string(),
4324
+ role: WorkspaceRoleSchema
4338
4325
  });
4339
- var EventVersionReleased = z156.object({
4340
- type: z156.literal("DesignSystemVersionReleased"),
4341
- workspaceId: z156.string(),
4342
- designSystemId: z156.string(),
4343
- versionId: z156.string()
4326
+ var DesignSystemInviteEmailData = z155.object({
4327
+ designSystem: DesignSystem,
4328
+ invitedBy: User,
4329
+ documentationDomain: z155.string().optional()
4344
4330
  });
4345
- var Event = z157.discriminatedUnion("type", [EventVersionReleased, EventDataSourceImported]);
4346
- var ExportJobDocumentationContext = z158.object({
4347
- isSingleVersionDocs: z158.boolean(),
4348
- versionSlug: z158.string(),
4331
+ var EventDataSourceImported = z156.object({
4332
+ type: z156.literal("DataSourceImported"),
4333
+ workspaceId: z156.string(),
4334
+ designSystemId: z156.string()
4335
+ });
4336
+ var EventVersionReleased = z157.object({
4337
+ type: z157.literal("DesignSystemVersionReleased"),
4338
+ workspaceId: z157.string(),
4339
+ designSystemId: z157.string(),
4340
+ versionId: z157.string()
4341
+ });
4342
+ var Event = z158.discriminatedUnion("type", [EventVersionReleased, EventDataSourceImported]);
4343
+ var ExportJobDocumentationContext = z159.object({
4344
+ isSingleVersionDocs: z159.boolean(),
4345
+ versionSlug: z159.string(),
4349
4346
  environment: PublishedDocEnvironment
4350
4347
  });
4351
- var ExportJobContext = z158.object({
4352
- apiUrl: z158.string(),
4353
- accessToken: z158.string(),
4354
- designSystemId: z158.string(),
4355
- designSystemName: z158.string(),
4356
- exporterId: z158.string(),
4357
- versionId: z158.string(),
4358
- brandId: z158.string().optional(),
4359
- themeId: z158.string().optional(),
4360
- themePersistentIds: z158.string().array().optional(),
4361
- exporterName: z158.string(),
4362
- exporterPackageUrl: z158.string(),
4348
+ var ExportJobContext = z159.object({
4349
+ apiUrl: z159.string(),
4350
+ accessToken: z159.string(),
4351
+ designSystemId: z159.string(),
4352
+ designSystemName: z159.string(),
4353
+ exporterId: z159.string(),
4354
+ versionId: z159.string(),
4355
+ brandId: z159.string().optional(),
4356
+ themeId: z159.string().optional(),
4357
+ themePersistentIds: z159.string().array().optional(),
4358
+ exporterName: z159.string(),
4359
+ exporterPackageUrl: z159.string(),
4363
4360
  exporterPropertyValues: ExporterPropertyValue.array(),
4364
4361
  documentation: ExportJobDocumentationContext.optional()
4365
4362
  });
4366
- var ExporterFunctionPayload = z159.object({
4367
- exportJobId: z159.string(),
4368
- exportContextId: z159.string(),
4369
- designSystemId: z159.string(),
4370
- workspaceId: z159.string()
4363
+ var ExporterFunctionPayload = z160.object({
4364
+ exportJobId: z160.string(),
4365
+ exportContextId: z160.string(),
4366
+ designSystemId: z160.string(),
4367
+ workspaceId: z160.string()
4371
4368
  });
4372
- var ExportJobDestinationType = z160.enum([
4369
+ var ExportJobDestinationType = z161.enum([
4373
4370
  "s3",
4374
4371
  "webhookUrl",
4375
4372
  "github",
@@ -4378,30 +4375,30 @@ var ExportJobDestinationType = z160.enum([
4378
4375
  "gitlab",
4379
4376
  "bitbucket"
4380
4377
  ]);
4381
- var ExportJobStatus = z160.enum(["InProgress", "Success", "Failed", "Timeout"]);
4382
- var ExportJobLogEntryType = z160.enum(["success", "info", "warning", "error", "user"]);
4383
- var ExportJobLogEntry = z160.object({
4384
- id: z160.string().optional(),
4385
- time: z160.coerce.date(),
4378
+ var ExportJobStatus = z161.enum(["InProgress", "Success", "Failed", "Timeout"]);
4379
+ var ExportJobLogEntryType = z161.enum(["success", "info", "warning", "error", "user"]);
4380
+ var ExportJobLogEntry = z161.object({
4381
+ id: z161.string().optional(),
4382
+ time: z161.coerce.date(),
4386
4383
  type: ExportJobLogEntryType,
4387
- message: z160.string()
4384
+ message: z161.string()
4388
4385
  });
4389
- var ExportJobPullRequestDestinationResult = z160.object({
4390
- pullRequestUrl: z160.string()
4386
+ var ExportJobPullRequestDestinationResult = z161.object({
4387
+ pullRequestUrl: z161.string()
4391
4388
  });
4392
- var ExportJobS3DestinationResult = z160.object({
4393
- bucket: z160.string(),
4394
- urlPrefix: z160.string().optional(),
4395
- path: z160.string(),
4396
- files: z160.array(z160.string()),
4397
- url: nullishToOptional(z160.string()),
4398
- urls: nullishToOptional(z160.string().array())
4389
+ var ExportJobS3DestinationResult = z161.object({
4390
+ bucket: z161.string(),
4391
+ urlPrefix: z161.string().optional(),
4392
+ path: z161.string(),
4393
+ files: z161.array(z161.string()),
4394
+ url: nullishToOptional(z161.string()),
4395
+ urls: nullishToOptional(z161.string().array())
4399
4396
  });
4400
- var ExportJobDocsDestinationResult = z160.object({
4401
- url: z160.string()
4397
+ var ExportJobDocsDestinationResult = z161.object({
4398
+ url: z161.string()
4402
4399
  });
4403
- var ExportJobResult = z160.object({
4404
- error: z160.string().optional(),
4400
+ var ExportJobResult = z161.object({
4401
+ error: z161.string().optional(),
4405
4402
  s3: nullishToOptional(ExportJobS3DestinationResult),
4406
4403
  github: nullishToOptional(ExportJobPullRequestDestinationResult),
4407
4404
  azure: nullishToOptional(ExportJobPullRequestDestinationResult),
@@ -4410,22 +4407,22 @@ var ExportJobResult = z160.object({
4410
4407
  sndocs: nullishToOptional(ExportJobDocsDestinationResult),
4411
4408
  logs: nullishToOptional(ExportJobLogEntry.array())
4412
4409
  });
4413
- var ExportJob = z160.object({
4414
- id: z160.string(),
4415
- createdAt: z160.coerce.date(),
4416
- finishedAt: z160.coerce.date().optional(),
4417
- designSystemId: z160.string(),
4418
- designSystemVersionId: z160.string(),
4419
- workspaceId: z160.string(),
4420
- scheduleId: z160.string().nullish(),
4421
- exporterId: z160.string(),
4422
- brandId: z160.string().optional(),
4423
- themeId: z160.string().optional(),
4424
- themePersistentIds: z160.string().array().optional(),
4425
- estimatedExecutionTime: z160.number().optional(),
4410
+ var ExportJob = z161.object({
4411
+ id: z161.string(),
4412
+ createdAt: z161.coerce.date(),
4413
+ finishedAt: z161.coerce.date().optional(),
4414
+ designSystemId: z161.string(),
4415
+ designSystemVersionId: z161.string(),
4416
+ workspaceId: z161.string(),
4417
+ scheduleId: z161.string().nullish(),
4418
+ exporterId: z161.string(),
4419
+ brandId: z161.string().optional(),
4420
+ themeId: z161.string().optional(),
4421
+ themePersistentIds: z161.string().array().optional(),
4422
+ estimatedExecutionTime: z161.number().optional(),
4426
4423
  status: ExportJobStatus,
4427
4424
  result: ExportJobResult.optional(),
4428
- createdByUserId: z160.string().optional(),
4425
+ createdByUserId: z161.string().optional(),
4429
4426
  // Destinations
4430
4427
  ...ExportDestinationsMap.shape
4431
4428
  });
@@ -4439,24 +4436,24 @@ var ExportJobFindByFilter = ExportJob.pick({
4439
4436
  themeId: true,
4440
4437
  brandId: true
4441
4438
  }).extend({
4442
- destinations: z160.array(ExportJobDestinationType),
4439
+ destinations: z161.array(ExportJobDestinationType),
4443
4440
  docsEnvironment: PublishedDocEnvironment
4444
4441
  }).partial();
4445
- var ExporterWorkspaceMembershipRole = z161.enum(["Owner", "OwnerArchived", "User"]);
4446
- var ExporterWorkspaceMembership = z162.object({
4447
- id: z162.string(),
4448
- workspaceId: z162.string(),
4449
- exporterId: z162.string(),
4442
+ var ExporterWorkspaceMembershipRole = z162.enum(["Owner", "OwnerArchived", "User"]);
4443
+ var ExporterWorkspaceMembership = z163.object({
4444
+ id: z163.string(),
4445
+ workspaceId: z163.string(),
4446
+ exporterId: z163.string(),
4450
4447
  role: ExporterWorkspaceMembershipRole
4451
4448
  });
4452
- var FlaggedFeature = z163.enum(["FigmaImporterV2", "ShadowOpacityOptional", "DisableImporter", "VariablesOrder"]);
4453
- var FeatureFlagMap = z163.record(FlaggedFeature, z163.boolean());
4454
- var FeatureFlag = z163.object({
4455
- id: z163.string(),
4449
+ var FlaggedFeature = z164.enum(["FigmaImporterV2", "ShadowOpacityOptional", "DisableImporter", "VariablesOrder"]);
4450
+ var FeatureFlagMap = z164.record(FlaggedFeature, z164.boolean());
4451
+ var FeatureFlag = z164.object({
4452
+ id: z164.string(),
4456
4453
  feature: FlaggedFeature,
4457
- createdAt: z163.coerce.date(),
4458
- enabled: z163.boolean(),
4459
- designSystemId: z163.string().optional()
4454
+ createdAt: z164.coerce.date(),
4455
+ enabled: z164.boolean(),
4456
+ designSystemId: z164.string().optional()
4460
4457
  });
4461
4458
  var OAuthProviderNames = /* @__PURE__ */ ((OAuthProviderNames2) => {
4462
4459
  OAuthProviderNames2["Figma"] = "figma";
@@ -4466,107 +4463,107 @@ var OAuthProviderNames = /* @__PURE__ */ ((OAuthProviderNames2) => {
4466
4463
  OAuthProviderNames2["Bitbucket"] = "bitbucket";
4467
4464
  return OAuthProviderNames2;
4468
4465
  })(OAuthProviderNames || {});
4469
- var OAuthProviderSchema = z164.nativeEnum(OAuthProviderNames);
4466
+ var OAuthProviderSchema = z165.nativeEnum(OAuthProviderNames);
4470
4467
  var OAuthProvider = OAuthProviderSchema.enum;
4471
- var ExternalOAuthRequest = z165.object({
4472
- id: z165.string(),
4468
+ var ExternalOAuthRequest = z166.object({
4469
+ id: z166.string(),
4473
4470
  provider: OAuthProviderSchema,
4474
- userId: z165.string(),
4475
- state: z165.string(),
4476
- createdAt: z165.coerce.date()
4471
+ userId: z166.string(),
4472
+ state: z166.string(),
4473
+ createdAt: z166.coerce.date()
4477
4474
  });
4478
- var GitObjectsQuery = z166.object({
4479
- organization: z166.string().optional(),
4475
+ var GitObjectsQuery = z167.object({
4476
+ organization: z167.string().optional(),
4480
4477
  // Azure Organization | Bitbucket Workspace slug | Gitlab Group | Github Account (User or Organization)
4481
- project: z166.string().optional(),
4478
+ project: z167.string().optional(),
4482
4479
  // Only for Bitbucket and Azure
4483
- repository: z166.string().optional(),
4480
+ repository: z167.string().optional(),
4484
4481
  // For all providers. For Gitlab, it's called "project".
4485
- branch: z166.string().optional(),
4482
+ branch: z167.string().optional(),
4486
4483
  // For all providers.
4487
- user: z166.string().optional()
4484
+ user: z167.string().optional()
4488
4485
  // Gitlab user
4489
4486
  });
4490
- var GitOrganization = z166.object({
4491
- id: z166.string(),
4492
- name: z166.string(),
4493
- url: z166.string(),
4494
- slug: z166.string()
4487
+ var GitOrganization = z167.object({
4488
+ id: z167.string(),
4489
+ name: z167.string(),
4490
+ url: z167.string(),
4491
+ slug: z167.string()
4495
4492
  });
4496
- var GitProject = z166.object({
4497
- id: z166.string(),
4498
- name: z166.string(),
4499
- url: z166.string(),
4500
- slug: z166.string()
4493
+ var GitProject = z167.object({
4494
+ id: z167.string(),
4495
+ name: z167.string(),
4496
+ url: z167.string(),
4497
+ slug: z167.string()
4501
4498
  });
4502
- var GitRepository = z166.object({
4503
- id: z166.string(),
4504
- name: z166.string(),
4505
- url: z166.string(),
4506
- slug: z166.string(),
4499
+ var GitRepository = z167.object({
4500
+ id: z167.string(),
4501
+ name: z167.string(),
4502
+ url: z167.string(),
4503
+ slug: z167.string(),
4507
4504
  /**
4508
4505
  * Can be undefined when:
4509
4506
  * - there are no branches in the repository yet
4510
4507
  * - Git provider doesn't expose this information on a repository via their API
4511
4508
  */
4512
- defaultBranch: z166.string().optional()
4509
+ defaultBranch: z167.string().optional()
4513
4510
  });
4514
- var GitBranch = z166.object({
4515
- name: z166.string(),
4516
- lastCommitId: z166.string()
4511
+ var GitBranch = z167.object({
4512
+ name: z167.string(),
4513
+ lastCommitId: z167.string()
4517
4514
  });
4518
- var IntegrationTokenSchemaOld = z167.object({
4519
- id: z167.string(),
4520
- provider: OAuthProviderSchema,
4521
- scope: z167.string(),
4522
- userId: z167.string(),
4523
- accessToken: z167.string(),
4524
- refreshToken: z167.string(),
4525
- expiresAt: z167.coerce.date(),
4526
- externalUserId: z167.string().nullish()
4527
- });
4528
- var WorkspaceOAuthRequestSchema = z168.object({
4515
+ var IntegrationTokenSchemaOld = z168.object({
4529
4516
  id: z168.string(),
4530
- workspaceId: z168.string(),
4531
4517
  provider: OAuthProviderSchema,
4518
+ scope: z168.string(),
4532
4519
  userId: z168.string(),
4533
- createdAt: z168.coerce.date()
4520
+ accessToken: z168.string(),
4521
+ refreshToken: z168.string(),
4522
+ expiresAt: z168.coerce.date(),
4523
+ externalUserId: z168.string().nullish()
4524
+ });
4525
+ var WorkspaceOAuthRequestSchema = z169.object({
4526
+ id: z169.string(),
4527
+ workspaceId: z169.string(),
4528
+ provider: OAuthProviderSchema,
4529
+ userId: z169.string(),
4530
+ createdAt: z169.coerce.date()
4534
4531
  });
4535
- var AnyRecord = z169.record(z169.any());
4532
+ var AnyRecord = z170.record(z170.any());
4536
4533
  var NpmPackageVersionDist = AnyRecord.and(
4537
- z169.object({
4538
- tarball: z169.string()
4534
+ z170.object({
4535
+ tarball: z170.string()
4539
4536
  })
4540
4537
  );
4541
4538
  var NpmPackageVersion = AnyRecord.and(
4542
- z169.object({
4539
+ z170.object({
4543
4540
  dist: NpmPackageVersionDist
4544
4541
  })
4545
4542
  );
4546
4543
  var NpmPackage = AnyRecord.and(
4547
- z169.object({
4548
- _id: z169.string(),
4549
- name: z169.string(),
4544
+ z170.object({
4545
+ _id: z170.string(),
4546
+ name: z170.string(),
4550
4547
  // e.g. "latest": "1.2.3"
4551
- "dist-tags": z169.record(z169.string(), z169.string()),
4548
+ "dist-tags": z170.record(z170.string(), z170.string()),
4552
4549
  // "1.2.3": {...}
4553
- versions: z169.record(NpmPackageVersion)
4550
+ versions: z170.record(NpmPackageVersion)
4554
4551
  })
4555
4552
  );
4556
- var NpmProxyTokenPayload = z170.object({
4557
- npmProxyRegistryConfigId: z170.string()
4553
+ var NpmProxyTokenPayload = z171.object({
4554
+ npmProxyRegistryConfigId: z171.string()
4558
4555
  });
4559
- var PersonalAccessToken = z171.object({
4560
- id: z171.string(),
4561
- userId: z171.string(),
4562
- workspaceId: z171.string().optional(),
4556
+ var PersonalAccessToken = z172.object({
4557
+ id: z172.string(),
4558
+ userId: z172.string(),
4559
+ workspaceId: z172.string().optional(),
4563
4560
  workspaceRole: WorkspaceRoleSchema.optional(),
4564
- name: z171.string(),
4565
- hidden: z171.boolean(),
4566
- token: z171.string(),
4567
- scope: z171.string().optional(),
4568
- createdAt: z171.coerce.date(),
4569
- expireAt: z171.coerce.date().optional()
4561
+ name: z172.string(),
4562
+ hidden: z172.boolean(),
4563
+ token: z172.string(),
4564
+ scope: z172.string().optional(),
4565
+ createdAt: z172.coerce.date(),
4566
+ expireAt: z172.coerce.date().optional()
4570
4567
  });
4571
4568
 
4572
4569
  // src/api/conversion/documentation/documentation-item-configuration-v1-to-dto.ts
@@ -4983,204 +4980,204 @@ function integrationCredentialToDto(credential) {
4983
4980
  }
4984
4981
 
4985
4982
  // src/api/dto/aux/pagination.ts
4986
- import { z as z172 } from "zod";
4987
- var DTOPagination = z172.object({
4988
- limit: z172.string().optional(),
4989
- offset: z172.string().optional()
4983
+ import { z as z173 } from "zod";
4984
+ var DTOPagination = z173.object({
4985
+ limit: z173.string().optional(),
4986
+ offset: z173.string().optional()
4990
4987
  });
4991
4988
 
4992
4989
  // src/api/dto/bff/app-bootstrap-data.ts
4993
- import { z as z197 } from "zod";
4990
+ import { z as z198 } from "zod";
4994
4991
 
4995
4992
  // src/api/dto/design-systems/brand.ts
4996
- import { z as z173 } from "zod";
4997
- var DTOBrand = z173.object({
4998
- id: z173.string(),
4999
- designSystemVersionId: z173.string(),
5000
- persistentId: z173.string(),
4993
+ import { z as z174 } from "zod";
4994
+ var DTOBrand = z174.object({
4995
+ id: z174.string(),
4996
+ designSystemVersionId: z174.string(),
4997
+ persistentId: z174.string(),
5001
4998
  meta: ObjectMeta
5002
4999
  });
5003
- var DTOBrandGetResponse = z173.object({ brand: DTOBrand });
5004
- var DTOBrandCreateResponse = z173.object({
5000
+ var DTOBrandGetResponse = z174.object({ brand: DTOBrand });
5001
+ var DTOBrandCreateResponse = z174.object({
5005
5002
  brand: DTOBrand
5006
5003
  });
5007
- var DTOBrandsListResponse = z173.object({ brands: z173.array(DTOBrand) });
5004
+ var DTOBrandsListResponse = z174.object({ brands: z174.array(DTOBrand) });
5008
5005
 
5009
5006
  // src/api/dto/design-systems/data-source.ts
5010
- import { z as z174 } from "zod";
5011
- var DTODataSourceFigmaFileVersion = z174.object({
5012
- id: z174.string(),
5013
- created_at: z174.coerce.date(),
5014
- label: z174.string(),
5015
- description: z174.string()
5016
- });
5017
- var DTODataSourceFigmaCloud = z174.object({
5018
- fileId: z174.string(),
5007
+ import { z as z175 } from "zod";
5008
+ var DTODataSourceFigmaFileVersion = z175.object({
5009
+ id: z175.string(),
5010
+ created_at: z175.coerce.date(),
5011
+ label: z175.string(),
5012
+ description: z175.string()
5013
+ });
5014
+ var DTODataSourceFigmaCloud = z175.object({
5015
+ fileId: z175.string(),
5019
5016
  state: DataSourceFigmaState,
5020
5017
  autoImportMode: DataSourceAutoImportMode,
5021
- fileThumbnailUrl: z174.string().optional(),
5018
+ fileThumbnailUrl: z175.string().optional(),
5022
5019
  lastImportResult: SourceImportSummary.nullish(),
5023
- lastImportedAt: z174.date().nullish(),
5020
+ lastImportedAt: z175.date().nullish(),
5024
5021
  lastImportedVersion: DTODataSourceFigmaFileVersion.nullish(),
5025
- lastUpdatesCheckedAt: z174.date().nullish(),
5026
- ownerId: z174.string(),
5027
- ownerUserName: z174.string().optional(),
5028
- preferredCredentialId: z174.string().optional(),
5022
+ lastUpdatesCheckedAt: z175.date().nullish(),
5023
+ ownerId: z175.string(),
5024
+ ownerUserName: z175.string().optional(),
5025
+ preferredCredentialId: z175.string().optional(),
5029
5026
  stats: DataSourceStats
5030
5027
  });
5031
- var DTODataSourceFigma = z174.object({
5032
- id: z174.string(),
5033
- type: z174.literal(DataSourceRemoteType.Enum.Figma),
5034
- fileName: z174.string(),
5028
+ var DTODataSourceFigma = z175.object({
5029
+ id: z175.string(),
5030
+ type: z175.literal(DataSourceRemoteType.Enum.Figma),
5031
+ fileName: z175.string(),
5035
5032
  scope: DataSourceFigmaScope,
5036
- brandId: z174.string(),
5037
- themeId: z174.string().nullish(),
5033
+ brandId: z175.string(),
5034
+ themeId: z175.string().nullish(),
5038
5035
  cloud: DTODataSourceFigmaCloud.nullish(),
5039
- tokenStudio: z174.literal(null),
5040
- upload: z174.literal(null),
5041
- figmaVariablesPlugin: z174.literal(null)
5042
- });
5043
- var DTODataSourceTokenStudio = z174.object({
5044
- id: z174.string(),
5045
- type: z174.literal(DataSourceRemoteType.Enum.TokenStudio),
5046
- fileName: z174.string(),
5047
- brandId: z174.string(),
5048
- themeId: z174.string().nullish(),
5049
- cloud: z174.literal(null),
5050
- tokenStudio: z174.object({
5051
- settings: z174.object({
5052
- dryRun: z174.boolean(),
5053
- verbose: z174.boolean(),
5054
- preciseCopy: z174.boolean()
5036
+ tokenStudio: z175.literal(null),
5037
+ upload: z175.literal(null),
5038
+ figmaVariablesPlugin: z175.literal(null)
5039
+ });
5040
+ var DTODataSourceTokenStudio = z175.object({
5041
+ id: z175.string(),
5042
+ type: z175.literal(DataSourceRemoteType.Enum.TokenStudio),
5043
+ fileName: z175.string(),
5044
+ brandId: z175.string(),
5045
+ themeId: z175.string().nullish(),
5046
+ cloud: z175.literal(null),
5047
+ tokenStudio: z175.object({
5048
+ settings: z175.object({
5049
+ dryRun: z175.boolean(),
5050
+ verbose: z175.boolean(),
5051
+ preciseCopy: z175.boolean()
5055
5052
  }),
5056
- connectionName: z174.string(),
5057
- lastImportedAt: z174.date(),
5058
- lastImportedResults: z174.array(
5059
- z174.object({
5060
- mapping: z174.object({
5061
- tokenSets: z174.array(z174.string()),
5062
- supernovaBrand: z174.string(),
5063
- supernovaTheme: z174.string().optional()
5053
+ connectionName: z175.string(),
5054
+ lastImportedAt: z175.date(),
5055
+ lastImportedResults: z175.array(
5056
+ z175.object({
5057
+ mapping: z175.object({
5058
+ tokenSets: z175.array(z175.string()),
5059
+ supernovaBrand: z175.string(),
5060
+ supernovaTheme: z175.string().optional()
5064
5061
  }),
5065
- isFailed: z174.boolean(),
5066
- tokensCreated: z174.number(),
5067
- tokensDeleted: z174.number(),
5068
- tokensUpdated: z174.number()
5062
+ isFailed: z175.boolean(),
5063
+ tokensCreated: z175.number(),
5064
+ tokensDeleted: z175.number(),
5065
+ tokensUpdated: z175.number()
5069
5066
  })
5070
5067
  )
5071
5068
  }),
5072
- upload: z174.literal(null),
5073
- figmaVariablesPlugin: z174.literal(null)
5074
- });
5075
- var DTODataSourceFigmaVariablesPlugin = z174.object({
5076
- id: z174.string(),
5077
- type: z174.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
5078
- fileName: z174.string(),
5079
- brandId: z174.string(),
5080
- themeId: z174.literal(null),
5081
- cloud: z174.literal(null),
5082
- tokenStudio: z174.literal(null),
5083
- upload: z174.object({
5084
- remoteId: z174.string(),
5069
+ upload: z175.literal(null),
5070
+ figmaVariablesPlugin: z175.literal(null)
5071
+ });
5072
+ var DTODataSourceFigmaVariablesPlugin = z175.object({
5073
+ id: z175.string(),
5074
+ type: z175.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
5075
+ fileName: z175.string(),
5076
+ brandId: z175.string(),
5077
+ themeId: z175.literal(null),
5078
+ cloud: z175.literal(null),
5079
+ tokenStudio: z175.literal(null),
5080
+ upload: z175.object({
5081
+ remoteId: z175.string(),
5085
5082
  remoteSourceType: DataSourceUploadRemoteSource,
5086
- lastImportedAt: z174.date().optional(),
5083
+ lastImportedAt: z175.date().optional(),
5087
5084
  lastImportMetadata: DataSourceUploadImportMetadata.optional()
5088
5085
  }),
5089
- figmaVariablesPlugin: z174.object({
5090
- fileId: z174.string(),
5091
- lastImportedAt: z174.date().optional(),
5086
+ figmaVariablesPlugin: z175.object({
5087
+ fileId: z175.string(),
5088
+ lastImportedAt: z175.date().optional(),
5092
5089
  lastImportMetadata: DataSourceUploadImportMetadata.optional()
5093
5090
  })
5094
5091
  });
5095
- var DTODataSource = z174.discriminatedUnion("type", [
5092
+ var DTODataSource = z175.discriminatedUnion("type", [
5096
5093
  DTODataSourceFigma,
5097
5094
  DTODataSourceFigmaVariablesPlugin,
5098
5095
  DTODataSourceTokenStudio
5099
5096
  ]);
5100
- var DTODataSourcesListResponse = z174.object({
5101
- sources: z174.array(DTODataSource)
5097
+ var DTODataSourcesListResponse = z175.object({
5098
+ sources: z175.array(DTODataSource)
5102
5099
  });
5103
- var DTODataSourceCreationResponse = z174.object({
5100
+ var DTODataSourceCreationResponse = z175.object({
5104
5101
  source: DTODataSource
5105
5102
  });
5106
5103
 
5107
5104
  // src/api/dto/design-systems/design-system.ts
5108
- import { z as z175 } from "zod";
5105
+ import { z as z176 } from "zod";
5109
5106
  var DTODesignSystem = DesignSystem.omit({
5110
5107
  name: true,
5111
5108
  description: true,
5112
5109
  docExporterId: true
5113
5110
  }).extend({
5114
5111
  meta: ObjectMeta,
5115
- docExporterId: z175.string(),
5116
- sources: z175.array(z175.any()),
5112
+ docExporterId: z176.string(),
5113
+ sources: z176.array(z176.any()),
5117
5114
  role: WorkspaceRoleSchema.optional()
5118
5115
  });
5119
- var DTODesignSystemResponse = z175.object({
5116
+ var DTODesignSystemResponse = z176.object({
5120
5117
  designSystem: DTODesignSystem
5121
5118
  });
5122
- var DTODesignSystemsListResponse = z175.object({
5119
+ var DTODesignSystemsListResponse = z176.object({
5123
5120
  designSystems: DTODesignSystem.array()
5124
5121
  });
5125
- var DTODesignSystemCreateInput = z175.object({
5126
- workspaceId: z175.string(),
5122
+ var DTODesignSystemCreateInput = z176.object({
5123
+ workspaceId: z176.string(),
5127
5124
  meta: ObjectMeta.optional(),
5128
- name: z175.string().min(2).max(64).optional(),
5129
- description: z175.string().max(1024).optional(),
5125
+ name: z176.string().min(2).max(64).optional(),
5126
+ description: z176.string().max(1024).optional(),
5130
5127
  accessMode: DesignSystemAccessMode.optional(),
5131
- inviteUserIds: z175.string().array().optional()
5128
+ inviteUserIds: z176.string().array().optional()
5132
5129
  });
5133
5130
 
5134
5131
  // src/api/dto/design-systems/elements-diff.ts
5135
- import { z as z176 } from "zod";
5136
- var DTODiffCountBase = z176.object({
5137
- created: z176.number(),
5138
- updated: z176.number(),
5139
- deleted: z176.number()
5132
+ import { z as z177 } from "zod";
5133
+ var DTODiffCountBase = z177.object({
5134
+ created: z177.number(),
5135
+ updated: z177.number(),
5136
+ deleted: z177.number()
5140
5137
  });
5141
- var DTODesignElementsDataDiffResponse = z176.object({
5138
+ var DTODesignElementsDataDiffResponse = z177.object({
5142
5139
  tokens: DTODiffCountBase,
5143
5140
  assets: DTODiffCountBase
5144
5141
  });
5145
5142
 
5146
5143
  // src/api/dto/design-systems/exporter-property.ts
5147
- import { z as z177 } from "zod";
5148
- var DTOExporterProperty = z177.any({});
5149
- var DTOExporterPropertyListResponse = z177.object({ items: z177.array(DTOExporterProperty) });
5144
+ import { z as z178 } from "zod";
5145
+ var DTOExporterProperty = z178.any({});
5146
+ var DTOExporterPropertyListResponse = z178.object({ items: z178.array(DTOExporterProperty) });
5150
5147
 
5151
5148
  // src/api/dto/design-systems/members.ts
5152
- import { z as z178 } from "zod";
5153
- var DTODesignSystemMember = z178.object({
5154
- userId: z178.string()
5149
+ import { z as z179 } from "zod";
5150
+ var DTODesignSystemMember = z179.object({
5151
+ userId: z179.string()
5155
5152
  });
5156
- var DTODesignSystemInvitation = z178.object({
5157
- id: z178.string(),
5158
- workspaceInvitationId: z178.string()
5153
+ var DTODesignSystemInvitation = z179.object({
5154
+ id: z179.string(),
5155
+ workspaceInvitationId: z179.string()
5159
5156
  });
5160
- var DTODesignSystemMemberListResponse = z178.object({
5157
+ var DTODesignSystemMemberListResponse = z179.object({
5161
5158
  members: DTODesignSystemMember.array(),
5162
5159
  invitations: DTODesignSystemInvitation.array()
5163
5160
  });
5164
- var DTODesignSystemMembersUpdateResponse = z178.object({
5165
- ok: z178.literal(true)
5161
+ var DTODesignSystemMembersUpdateResponse = z179.object({
5162
+ ok: z179.literal(true)
5166
5163
  });
5167
5164
  var DTODesignSystemMembersUpdatePayload = DesignSystemMembershipUpdates;
5168
5165
 
5169
5166
  // src/api/dto/design-systems/version.ts
5170
- import { z as z189 } from "zod";
5167
+ import { z as z190 } from "zod";
5171
5168
 
5172
5169
  // src/api/payloads/design-systems/brand.ts
5173
- import { z as z179 } from "zod";
5174
- var DTOCreateBrandInput = z179.object({
5175
- persistentId: z179.string().uuid(),
5176
- meta: z179.object({
5177
- name: z179.string(),
5178
- description: z179.string()
5170
+ import { z as z180 } from "zod";
5171
+ var DTOCreateBrandInput = z180.object({
5172
+ persistentId: z180.string().uuid(),
5173
+ meta: z180.object({
5174
+ name: z180.string(),
5175
+ description: z180.string()
5179
5176
  })
5180
5177
  });
5181
5178
 
5182
5179
  // src/api/payloads/design-systems/update-design-system.ts
5183
- import { z as z180 } from "zod";
5180
+ import { z as z181 } from "zod";
5184
5181
  var DTODesignSystemUpdateInput = DesignSystem.partial().omit({
5185
5182
  id: true,
5186
5183
  workspaceId: true,
@@ -5192,40 +5189,40 @@ var DTODesignSystemUpdateInput = DesignSystem.partial().omit({
5192
5189
  }).extend({
5193
5190
  meta: ObjectMeta.partial().optional()
5194
5191
  });
5195
- var DTODesignSystemUpdateAccessModeInput = z180.object({
5192
+ var DTODesignSystemUpdateAccessModeInput = z181.object({
5196
5193
  accessMode: DesignSystemAccessMode,
5197
- retain: z180.object({
5198
- userIds: z180.string().array(),
5199
- inviteIds: z180.string().array()
5194
+ retain: z181.object({
5195
+ userIds: z181.string().array(),
5196
+ inviteIds: z181.string().array()
5200
5197
  }).optional()
5201
5198
  });
5202
5199
 
5203
5200
  // src/api/payloads/design-systems/version.ts
5204
- import { z as z181 } from "zod";
5205
- var ObjectMeta2 = z181.object({
5206
- name: z181.string().max(150).optional(),
5207
- description: z181.string().max(2e3).optional()
5201
+ import { z as z182 } from "zod";
5202
+ var ObjectMeta2 = z182.object({
5203
+ name: z182.string().max(150).optional(),
5204
+ description: z182.string().max(2e3).optional()
5208
5205
  });
5209
5206
  function validateDesignSystemVersion(version) {
5210
5207
  const urlCompliantRegex = /^[a-zA-Z0-9+.-]+$/;
5211
5208
  return urlCompliantRegex.test(version);
5212
5209
  }
5213
- var DTOCreateVersionInput = z181.object({
5210
+ var DTOCreateVersionInput = z182.object({
5214
5211
  meta: ObjectMeta2,
5215
- version: z181.string().refine(validateDesignSystemVersion, {
5212
+ version: z182.string().refine(validateDesignSystemVersion, {
5216
5213
  message: "Invalid semantic versioning format"
5217
5214
  }),
5218
- changeLog: z181.string().optional()
5215
+ changeLog: z182.string().optional()
5219
5216
  });
5220
- var DTOUpdateVersionInput = z181.object({
5217
+ var DTOUpdateVersionInput = z182.object({
5221
5218
  meta: ObjectMeta2,
5222
- version: z181.string(),
5219
+ version: z182.string(),
5223
5220
  // required for PUT, but not editable
5224
- changeLog: z181.string()
5221
+ changeLog: z182.string()
5225
5222
  });
5226
5223
 
5227
5224
  // src/api/payloads/documentation/block-definitions.ts
5228
- import { z as z182 } from "zod";
5225
+ import { z as z183 } from "zod";
5229
5226
 
5230
5227
  // src/api/dto/documentation/block-definition.ts
5231
5228
  var DTOPageBlockDefinitionBehavior = PageBlockDefinitionBehavior;
@@ -5237,60 +5234,60 @@ var DTOPageBlockColorV2 = PageBlockColorV2;
5237
5234
  var DTOPageBlockDefinition = PageBlockDefinition;
5238
5235
 
5239
5236
  // src/api/payloads/documentation/block-definitions.ts
5240
- var DTOGetBlockDefinitionsOutput = z182.object({
5241
- definitions: z182.array(DTOPageBlockDefinition)
5237
+ var DTOGetBlockDefinitionsOutput = z183.object({
5238
+ definitions: z183.array(DTOPageBlockDefinition)
5242
5239
  });
5243
5240
 
5244
5241
  // src/api/payloads/documentation/design-data-doc-diff.ts
5245
- import { z as z183 } from "zod";
5246
- var DTODocumentationPublishTypeQueryParams = z183.object({
5247
- environment: z183.enum(["Live", "Preview"])
5242
+ import { z as z184 } from "zod";
5243
+ var DTODocumentationPublishTypeQueryParams = z184.object({
5244
+ environment: z184.enum(["Live", "Preview"])
5248
5245
  });
5249
5246
 
5250
5247
  // src/api/payloads/export/pipeline.ts
5251
- import { z as z184 } from "zod";
5252
- var DTOPipelineCreateBody = z184.object({
5253
- name: z184.string(),
5254
- exporterId: z184.string(),
5255
- designSystemId: z184.string(),
5256
- isEnabled: z184.boolean(),
5248
+ import { z as z185 } from "zod";
5249
+ var DTOPipelineCreateBody = z185.object({
5250
+ name: z185.string(),
5251
+ exporterId: z185.string(),
5252
+ designSystemId: z185.string(),
5253
+ isEnabled: z185.boolean(),
5257
5254
  eventType: PipelineEventType,
5258
- brandPersistentId: z184.string().optional(),
5259
- themePersistentId: z184.string().optional(),
5260
- themePersistentIds: z184.string().array().optional(),
5255
+ brandPersistentId: z185.string().optional(),
5256
+ themePersistentId: z185.string().optional(),
5257
+ themePersistentIds: z185.string().array().optional(),
5261
5258
  destination: PipelineDestinationType.optional(),
5262
5259
  gitQuery: GitObjectsQuery,
5263
- destinations: z184.object({
5260
+ destinations: z185.object({
5264
5261
  s3: ExporterDestinationS3.nullish(),
5265
5262
  azure: ExporterDestinationAzure.nullish(),
5266
5263
  bitbucket: ExporterDestinationBitbucket.nullish(),
5267
5264
  github: ExporterDestinationGithub.nullish(),
5268
5265
  gitlab: ExporterDestinationGitlab.nullish(),
5269
5266
  documentation: ExporterDestinationDocs.nullish(),
5270
- webhookUrl: z184.string().nullish()
5267
+ webhookUrl: z185.string().nullish()
5271
5268
  })
5272
5269
  });
5273
5270
  var DTOPipelineUpdateBody = DTOPipelineCreateBody.extend({
5274
- id: z184.string()
5271
+ id: z185.string()
5275
5272
  });
5276
- var DTOPipelineTriggerBody = z184.object({
5277
- designSystemVersionId: z184.string()
5273
+ var DTOPipelineTriggerBody = z185.object({
5274
+ designSystemVersionId: z185.string()
5278
5275
  });
5279
5276
 
5280
5277
  // src/api/payloads/liveblocks/auth.ts
5281
- import { z as z185 } from "zod";
5282
- var DTOLiveblocksAuthRequest = z185.object({
5283
- room: z185.string().optional()
5278
+ import { z as z186 } from "zod";
5279
+ var DTOLiveblocksAuthRequest = z186.object({
5280
+ room: z186.string().optional()
5284
5281
  });
5285
5282
 
5286
5283
  // src/api/payloads/users/notifications/notification-settings.ts
5287
- import { z as z186 } from "zod";
5288
- var DTOUpdateUserNotificationSettingsPayload = z186.object({
5284
+ import { z as z187 } from "zod";
5285
+ var DTOUpdateUserNotificationSettingsPayload = z187.object({
5289
5286
  notificationSettings: UserNotificationSettings
5290
5287
  });
5291
- var DTOUserNotificationSettingsResponse = z186.object({
5292
- userId: z186.string(),
5293
- workspaceId: z186.string(),
5288
+ var DTOUserNotificationSettingsResponse = z187.object({
5289
+ userId: z187.string(),
5290
+ workspaceId: z187.string(),
5294
5291
  notificationSettings: UserNotificationSettings
5295
5292
  });
5296
5293
 
@@ -5298,7 +5295,7 @@ var DTOUserNotificationSettingsResponse = z186.object({
5298
5295
  var DTOUserProfileUpdatePayload = UserProfileUpdate;
5299
5296
 
5300
5297
  // src/api/payloads/workspaces/workspace-configuration.ts
5301
- import { z as z187 } from "zod";
5298
+ import { z as z188 } from "zod";
5302
5299
  var prohibitedSsoKeys = ["providerId", "metadataXml", "emailDomains"];
5303
5300
  function validateSsoPayload(ssoPayload) {
5304
5301
  const keys = [];
@@ -5321,21 +5318,21 @@ function validateSsoPayload(ssoPayload) {
5321
5318
  keys
5322
5319
  };
5323
5320
  }
5324
- var NpmRegistryInput = z187.object({
5325
- enabledScopes: z187.array(z187.string()),
5326
- customRegistryUrl: z187.string().optional(),
5327
- bypassProxy: z187.boolean().optional(),
5328
- npmProxyRegistryConfigId: z187.string().optional(),
5329
- npmProxyVersion: z187.number().optional(),
5330
- registryType: z187.string(),
5331
- authType: z187.string(),
5332
- authHeaderName: z187.string(),
5333
- authHeaderValue: z187.string(),
5334
- accessToken: z187.string(),
5335
- username: z187.string(),
5336
- password: z187.string()
5337
- });
5338
- var WorkspaceConfigurationPayload = z187.object({
5321
+ var NpmRegistryInput = z188.object({
5322
+ enabledScopes: z188.array(z188.string()),
5323
+ customRegistryUrl: z188.string().optional(),
5324
+ bypassProxy: z188.boolean().optional(),
5325
+ npmProxyRegistryConfigId: z188.string().optional(),
5326
+ npmProxyVersion: z188.number().optional(),
5327
+ registryType: z188.string(),
5328
+ authType: z188.string(),
5329
+ authHeaderName: z188.string(),
5330
+ authHeaderValue: z188.string(),
5331
+ accessToken: z188.string(),
5332
+ username: z188.string(),
5333
+ password: z188.string()
5334
+ });
5335
+ var WorkspaceConfigurationPayload = z188.object({
5339
5336
  ipWhitelist: WorkspaceIpSettings.partial().optional(),
5340
5337
  sso: SsoProvider.partial().optional(),
5341
5338
  npmRegistrySettings: NpmRegistryInput.partial().optional(),
@@ -5343,211 +5340,211 @@ var WorkspaceConfigurationPayload = z187.object({
5343
5340
  });
5344
5341
 
5345
5342
  // src/api/payloads/workspaces/workspace-integrations.ts
5346
- import { z as z188 } from "zod";
5347
- var DTOWorkspaceIntegrationOauthInput = z188.object({
5343
+ import { z as z189 } from "zod";
5344
+ var DTOWorkspaceIntegrationOauthInput = z189.object({
5348
5345
  type: IntegrationType
5349
5346
  });
5350
- var DTOWorkspaceIntegrationPATInput = z188.object({
5351
- userId: z188.string(),
5347
+ var DTOWorkspaceIntegrationPATInput = z189.object({
5348
+ userId: z189.string(),
5352
5349
  type: IntegrationType,
5353
5350
  token: IntegrationToken
5354
5351
  });
5355
- var DTOWorkspaceIntegrationGetGitObjectsInput = z188.object({
5356
- organization: z188.string().optional(),
5352
+ var DTOWorkspaceIntegrationGetGitObjectsInput = z189.object({
5353
+ organization: z189.string().optional(),
5357
5354
  // Azure Organization | Bitbucket Workspace slug | Gitlab Group and Sub-Groups | Github Account (User or Organization)
5358
- project: z188.string().optional(),
5355
+ project: z189.string().optional(),
5359
5356
  // Only for Bitbucket and Azure
5360
- repository: z188.string().optional(),
5357
+ repository: z189.string().optional(),
5361
5358
  // For all providers. Pay attention for Gitlab, they call repositories "projects".
5362
- branch: z188.string().optional(),
5359
+ branch: z189.string().optional(),
5363
5360
  // For all providers, useful for PR creations.
5364
- user: z188.string().optional()
5361
+ user: z189.string().optional()
5365
5362
  // Only for Gitlab User Repositories
5366
5363
  });
5367
5364
 
5368
5365
  // src/api/dto/design-systems/version.ts
5369
- var DTODesignSystemVersion = z189.object({
5370
- id: z189.string(),
5371
- createdAt: z189.date(),
5366
+ var DTODesignSystemVersion = z190.object({
5367
+ id: z190.string(),
5368
+ createdAt: z190.date(),
5372
5369
  meta: ObjectMeta,
5373
- version: z189.string(),
5374
- isReadonly: z189.boolean(),
5375
- changeLog: z189.string(),
5376
- designSystemId: z189.string()
5370
+ version: z190.string(),
5371
+ isReadonly: z190.boolean(),
5372
+ changeLog: z190.string(),
5373
+ designSystemId: z190.string()
5377
5374
  });
5378
- var DTODesignSystemVersionsListResponse = z189.object({
5379
- designSystemVersions: z189.array(DTODesignSystemVersion)
5375
+ var DTODesignSystemVersionsListResponse = z190.object({
5376
+ designSystemVersions: z190.array(DTODesignSystemVersion)
5380
5377
  });
5381
- var DTODesignSystemVersionGetResponse = z189.object({
5378
+ var DTODesignSystemVersionGetResponse = z190.object({
5382
5379
  designSystemVersion: DTODesignSystemVersion
5383
5380
  });
5384
- var DTODesignSystemVersionCreationResponse = z189.object({
5381
+ var DTODesignSystemVersionCreationResponse = z190.object({
5385
5382
  meta: ObjectMeta,
5386
- version: z189.string(),
5387
- changeLog: z189.string(),
5388
- isReadOnly: z189.boolean(),
5389
- designSystemId: z189.string(),
5390
- jobId: z189.string()
5391
- });
5392
- var VersionSQSPayload = z189.object({
5393
- jobId: z189.string(),
5394
- designSystemId: z189.string(),
5383
+ version: z190.string(),
5384
+ changeLog: z190.string(),
5385
+ isReadOnly: z190.boolean(),
5386
+ designSystemId: z190.string(),
5387
+ jobId: z190.string()
5388
+ });
5389
+ var VersionSQSPayload = z190.object({
5390
+ jobId: z190.string(),
5391
+ designSystemId: z190.string(),
5395
5392
  input: DTOCreateVersionInput
5396
5393
  });
5397
- var DTODesignSystemVersionJobsResponse = z189.object({
5398
- jobs: z189.array(VersionCreationJob)
5394
+ var DTODesignSystemVersionJobsResponse = z190.object({
5395
+ jobs: z190.array(VersionCreationJob)
5399
5396
  });
5400
- var DTODesignSystemVersionJobStatusResponse = z189.object({
5397
+ var DTODesignSystemVersionJobStatusResponse = z190.object({
5401
5398
  job: VersionCreationJob
5402
5399
  });
5403
5400
 
5404
5401
  // src/api/dto/design-systems/view.ts
5405
- import { z as z190 } from "zod";
5406
- var DTOElementViewColumnSharedAttributes = z190.object({
5407
- id: z190.string(),
5408
- persistentId: z190.string(),
5409
- width: z190.number()
5402
+ import { z as z191 } from "zod";
5403
+ var DTOElementViewColumnSharedAttributes = z191.object({
5404
+ id: z191.string(),
5405
+ persistentId: z191.string(),
5406
+ width: z191.number()
5410
5407
  });
5411
5408
  var DTOElementViewBasePropertyColumn = DTOElementViewColumnSharedAttributes.extend({
5412
- type: z190.literal("BaseProperty"),
5409
+ type: z191.literal("BaseProperty"),
5413
5410
  basePropertyType: ElementViewBaseColumnType
5414
5411
  });
5415
5412
  var DTOElementViewPropertyDefinitionColumn = DTOElementViewColumnSharedAttributes.extend({
5416
- type: z190.literal("PropertyDefinition"),
5417
- propertyDefinitionId: z190.string()
5413
+ type: z191.literal("PropertyDefinition"),
5414
+ propertyDefinitionId: z191.string()
5418
5415
  });
5419
5416
  var DTOElementViewThemeColumn = DTOElementViewColumnSharedAttributes.extend({
5420
- type: z190.literal("Theme"),
5421
- themeId: z190.string()
5417
+ type: z191.literal("Theme"),
5418
+ themeId: z191.string()
5422
5419
  });
5423
- var DTOElementViewColumn = z190.discriminatedUnion("type", [
5420
+ var DTOElementViewColumn = z191.discriminatedUnion("type", [
5424
5421
  DTOElementViewBasePropertyColumn,
5425
5422
  DTOElementViewPropertyDefinitionColumn,
5426
5423
  DTOElementViewThemeColumn
5427
5424
  ]);
5428
- var DTOElementView = z190.object({
5425
+ var DTOElementView = z191.object({
5429
5426
  meta: ObjectMeta,
5430
- persistentId: z190.string(),
5427
+ persistentId: z191.string(),
5431
5428
  targetElementType: ElementPropertyTargetType,
5432
- id: z190.string(),
5433
- isDefault: z190.boolean(),
5434
- columns: z190.array(DTOElementViewColumn)
5429
+ id: z191.string(),
5430
+ isDefault: z191.boolean(),
5431
+ columns: z191.array(DTOElementViewColumn)
5435
5432
  });
5436
- var DTOElementViewsListResponse = z190.object({
5437
- elementDataViews: z190.array(DTOElementView)
5433
+ var DTOElementViewsListResponse = z191.object({
5434
+ elementDataViews: z191.array(DTOElementView)
5438
5435
  });
5439
5436
 
5440
5437
  // src/api/dto/workspaces/git.ts
5441
- import { z as z191 } from "zod";
5442
- var DTOGitOrganization = z191.object({
5443
- id: z191.string(),
5444
- name: z191.string(),
5445
- url: z191.string(),
5446
- slug: z191.string()
5438
+ import { z as z192 } from "zod";
5439
+ var DTOGitOrganization = z192.object({
5440
+ id: z192.string(),
5441
+ name: z192.string(),
5442
+ url: z192.string(),
5443
+ slug: z192.string()
5447
5444
  });
5448
- var DTOGitProject = z191.object({
5449
- id: z191.string(),
5450
- name: z191.string(),
5451
- url: z191.string(),
5452
- slug: z191.string()
5445
+ var DTOGitProject = z192.object({
5446
+ id: z192.string(),
5447
+ name: z192.string(),
5448
+ url: z192.string(),
5449
+ slug: z192.string()
5453
5450
  });
5454
- var DTOGitRepository = z191.object({
5455
- id: z191.string(),
5456
- name: z191.string(),
5457
- url: z191.string(),
5458
- slug: z191.string(),
5459
- defaultBranch: z191.string().optional()
5451
+ var DTOGitRepository = z192.object({
5452
+ id: z192.string(),
5453
+ name: z192.string(),
5454
+ url: z192.string(),
5455
+ slug: z192.string(),
5456
+ defaultBranch: z192.string().optional()
5460
5457
  });
5461
- var DTOGitBranch = z191.object({
5462
- name: z191.string(),
5463
- lastCommitId: z191.string()
5458
+ var DTOGitBranch = z192.object({
5459
+ name: z192.string(),
5460
+ lastCommitId: z192.string()
5464
5461
  });
5465
5462
 
5466
5463
  // src/api/dto/workspaces/integrations.ts
5467
- import { z as z192 } from "zod";
5464
+ import { z as z193 } from "zod";
5468
5465
  var DTOIntegrationCredentials = IntegrationCredentials.omit({
5469
5466
  accessToken: true,
5470
5467
  refreshToken: true
5471
5468
  });
5472
- var DTOIntegration = z192.object({
5473
- id: z192.string(),
5474
- workspaceId: z192.string(),
5469
+ var DTOIntegration = z193.object({
5470
+ id: z193.string(),
5471
+ workspaceId: z193.string(),
5475
5472
  type: ExtendedIntegrationType,
5476
- createdAt: z192.coerce.date(),
5477
- integrationCredentials: z192.array(DTOIntegrationCredentials).optional(),
5478
- integrationDesignSystems: z192.array(IntegrationDesignSystem).optional()
5473
+ createdAt: z193.coerce.date(),
5474
+ integrationCredentials: z193.array(DTOIntegrationCredentials).optional(),
5475
+ integrationDesignSystems: z193.array(IntegrationDesignSystem).optional()
5479
5476
  });
5480
- var DTOIntegrationOAuthGetResponse = z192.object({
5481
- url: z192.string()
5477
+ var DTOIntegrationOAuthGetResponse = z193.object({
5478
+ url: z193.string()
5482
5479
  });
5483
- var DTOIntegrationPostResponse = z192.object({
5480
+ var DTOIntegrationPostResponse = z193.object({
5484
5481
  integration: DTOIntegration
5485
5482
  });
5486
- var DTOIntegrationsGetListResponse = z192.object({
5483
+ var DTOIntegrationsGetListResponse = z193.object({
5487
5484
  integrations: DTOIntegration.array()
5488
5485
  });
5489
5486
 
5490
5487
  // src/api/dto/workspaces/invitations.ts
5491
- import { z as z193 } from "zod";
5492
- var DTOWorkspaceInvitationInput = z193.object({
5493
- email: z193.string().email(),
5488
+ import { z as z194 } from "zod";
5489
+ var DTOWorkspaceInvitationInput = z194.object({
5490
+ email: z194.string().email(),
5494
5491
  role: WorkspaceRoleSchema
5495
5492
  });
5496
- var DTOWorkspaceInvitationsListInput = z193.object({
5493
+ var DTOWorkspaceInvitationsListInput = z194.object({
5497
5494
  invites: DTOWorkspaceInvitationInput.array().max(100),
5498
- designSystemId: z193.string().optional()
5495
+ designSystemId: z194.string().optional()
5499
5496
  });
5500
- var DTOWorkspaceInvitationsResponse = z193.object({
5497
+ var DTOWorkspaceInvitationsResponse = z194.object({
5501
5498
  invitations: WorkspaceInvitation.array()
5502
5499
  });
5503
5500
 
5504
5501
  // src/api/dto/workspaces/membership.ts
5505
- import { z as z196 } from "zod";
5502
+ import { z as z197 } from "zod";
5506
5503
 
5507
5504
  // src/api/dto/workspaces/workspace.ts
5508
- import { z as z195 } from "zod";
5505
+ import { z as z196 } from "zod";
5509
5506
 
5510
5507
  // src/api/dto/workspaces/npm-registry.ts
5511
- import { z as z194 } from "zod";
5508
+ import { z as z195 } from "zod";
5512
5509
  var DTONpmRegistryConfigConstants = {
5513
5510
  passwordPlaceholder: "redacted"
5514
5511
  };
5515
- var DTONpmRegistryConfig = z194.object({
5512
+ var DTONpmRegistryConfig = z195.object({
5516
5513
  // Registry basic configuration
5517
5514
  registryType: NpmRegistryType,
5518
- registryUrl: z194.string(),
5519
- customRegistryUrl: z194.string().optional(),
5515
+ registryUrl: z195.string(),
5516
+ customRegistryUrl: z195.string().optional(),
5520
5517
  // URL of Supernova NPM packages proxy
5521
- proxyUrl: z194.string(),
5518
+ proxyUrl: z195.string(),
5522
5519
  // Auth configuration
5523
5520
  authType: NpmRegistryAuthType,
5524
- accessToken: z194.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
5525
- username: z194.string().optional(),
5526
- password: z194.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
5521
+ accessToken: z195.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
5522
+ username: z195.string().optional(),
5523
+ password: z195.literal(DTONpmRegistryConfigConstants.passwordPlaceholder).optional(),
5527
5524
  // NPM package scopes for whih the proxy should be enabled
5528
- enabledScopes: z194.array(z194.string()),
5525
+ enabledScopes: z195.array(z195.string()),
5529
5526
  // True if client should bypass Supernova proxy and connect directly to the registry
5530
5527
  // (e.g. when the NPM registry is behind a VPN or firewall which prevents Supernova from accessing it)
5531
- bypassProxy: z194.boolean()
5528
+ bypassProxy: z195.boolean()
5532
5529
  });
5533
5530
 
5534
5531
  // src/api/dto/workspaces/workspace.ts
5535
- var DTOWorkspace = z195.object({
5536
- id: z195.string(),
5532
+ var DTOWorkspace = z196.object({
5533
+ id: z196.string(),
5537
5534
  profile: WorkspaceProfile,
5538
5535
  subscription: Subscription,
5539
5536
  npmRegistry: DTONpmRegistryConfig.optional()
5540
5537
  });
5541
- var DTOWorkspaceCreateInput = z195.object({
5542
- name: z195.string()
5538
+ var DTOWorkspaceCreateInput = z196.object({
5539
+ name: z196.string()
5543
5540
  });
5544
- var DTOWorkspaceResponse = z195.object({
5541
+ var DTOWorkspaceResponse = z196.object({
5545
5542
  workspace: DTOWorkspace
5546
5543
  });
5547
5544
 
5548
5545
  // src/api/dto/workspaces/membership.ts
5549
- var DTOWorkspaceRole = z196.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Contributor"]);
5550
- var DTOUserWorkspaceMembership = z196.object({
5546
+ var DTOWorkspaceRole = z197.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Contributor"]);
5547
+ var DTOUserWorkspaceMembership = z197.object({
5551
5548
  // Workspace the user is a member of
5552
5549
  workspace: DTOWorkspace,
5553
5550
  // Assigned role the user has in the workspace
@@ -5557,18 +5554,18 @@ var DTOUserWorkspaceMembership = z196.object({
5557
5554
  // when a workspace's subscription is downgraded to free tier
5558
5555
  effectiveRole: DTOWorkspaceRole
5559
5556
  });
5560
- var DTOUserWorkspaceMembershipsResponse = z196.object({
5561
- membership: z196.array(DTOUserWorkspaceMembership)
5557
+ var DTOUserWorkspaceMembershipsResponse = z197.object({
5558
+ membership: z197.array(DTOUserWorkspaceMembership)
5562
5559
  });
5563
5560
 
5564
5561
  // src/api/dto/bff/app-bootstrap-data.ts
5565
- var DTOAppBootstrapDataQuery = z197.object({
5566
- preferredWorkspaceId: z197.string().optional(),
5567
- preferredDesignSystemId: z197.string().optional(),
5568
- preferredVersionId: z197.string().optional(),
5569
- preferredBrandId: z197.string().optional()
5562
+ var DTOAppBootstrapDataQuery = z198.object({
5563
+ preferredWorkspaceId: z198.string().optional(),
5564
+ preferredDesignSystemId: z198.string().optional(),
5565
+ preferredVersionId: z198.string().optional(),
5566
+ preferredBrandId: z198.string().optional()
5570
5567
  });
5571
- var DTOAppBootstrapDataResponse = z197.object({
5568
+ var DTOAppBootstrapDataResponse = z198.object({
5572
5569
  workspaceMembership: DTOUserWorkspaceMembership.optional(),
5573
5570
  designSystem: DTODesignSystem.optional(),
5574
5571
  version: DTODesignSystemVersion.optional(),
@@ -5576,19 +5573,19 @@ var DTOAppBootstrapDataResponse = z197.object({
5576
5573
  });
5577
5574
 
5578
5575
  // src/api/dto/documentation/anchor.ts
5579
- import { z as z198 } from "zod";
5576
+ import { z as z199 } from "zod";
5580
5577
  var DTODocumentationPageAnchor = DocumentationPageAnchor;
5581
- var DTOGetDocumentationPageAnchorsResponse = z198.object({
5582
- anchors: z198.array(DTODocumentationPageAnchor)
5578
+ var DTOGetDocumentationPageAnchorsResponse = z199.object({
5579
+ anchors: z199.array(DTODocumentationPageAnchor)
5583
5580
  });
5584
5581
 
5585
5582
  // src/api/dto/documentation/approvals.ts
5586
- import { z as z199 } from "zod";
5583
+ import { z as z200 } from "zod";
5587
5584
  var DTODocumentationPageApprovalState = DocumentationPageApproval;
5588
- var DTODocumentationGroupApprovalState = z199.object({
5589
- persistentId: z199.string(),
5590
- groupId: z199.string(),
5591
- designSystemVersionId: z199.string(),
5585
+ var DTODocumentationGroupApprovalState = z200.object({
5586
+ persistentId: z200.string(),
5587
+ groupId: z200.string(),
5588
+ designSystemVersionId: z200.string(),
5592
5589
  approvalState: DocumentationPageApprovalState
5593
5590
  });
5594
5591
 
@@ -5596,68 +5593,68 @@ var DTODocumentationGroupApprovalState = z199.object({
5596
5593
  var DTOPageBlockItemV2 = PageBlockItemV2;
5597
5594
 
5598
5595
  // src/api/dto/documentation/documentation-page-snapshot.ts
5599
- import { z as z204 } from "zod";
5596
+ import { z as z205 } from "zod";
5600
5597
 
5601
5598
  // src/api/dto/elements/documentation/page-v2.ts
5602
- import { z as z203 } from "zod";
5599
+ import { z as z204 } from "zod";
5603
5600
 
5604
5601
  // src/api/dto/elements/documentation/draft-state.ts
5605
- import { z as z201 } from "zod";
5602
+ import { z as z202 } from "zod";
5606
5603
 
5607
5604
  // src/api/dto/elements/documentation/item-configuration-v2.ts
5608
- import { z as z200 } from "zod";
5605
+ import { z as z201 } from "zod";
5609
5606
  var DTODocumentationItemHeaderV2 = DocumentationItemHeaderV2;
5610
- var DTODocumentationItemConfigurationV2 = z200.object({
5611
- showSidebar: z200.boolean(),
5612
- isPrivate: z200.boolean(),
5613
- isHidden: z200.boolean(),
5607
+ var DTODocumentationItemConfigurationV2 = z201.object({
5608
+ showSidebar: z201.boolean(),
5609
+ isPrivate: z201.boolean(),
5610
+ isHidden: z201.boolean(),
5614
5611
  header: DTODocumentationItemHeaderV2
5615
5612
  });
5616
5613
 
5617
5614
  // src/api/dto/elements/documentation/draft-state.ts
5618
- var DTODocumentationDraftChangeType = z201.enum(["Created", "Updated", "Deleted"]);
5619
- var DTODocumentationDraftStateCreated = z201.object({
5620
- changeType: z201.literal(DTODocumentationDraftChangeType.enum.Created)
5621
- });
5622
- var DTODocumentationDraftStateUpdated = z201.object({
5623
- changeType: z201.literal(DTODocumentationDraftChangeType.enum.Updated),
5624
- changes: z201.object({
5625
- previousTitle: z201.string().optional(),
5615
+ var DTODocumentationDraftChangeType = z202.enum(["Created", "Updated", "Deleted"]);
5616
+ var DTODocumentationDraftStateCreated = z202.object({
5617
+ changeType: z202.literal(DTODocumentationDraftChangeType.enum.Created)
5618
+ });
5619
+ var DTODocumentationDraftStateUpdated = z202.object({
5620
+ changeType: z202.literal(DTODocumentationDraftChangeType.enum.Updated),
5621
+ changes: z202.object({
5622
+ previousTitle: z202.string().optional(),
5626
5623
  previousConfiguration: DTODocumentationItemConfigurationV2.optional(),
5627
- previousContentHash: z201.string().optional()
5624
+ previousContentHash: z202.string().optional()
5628
5625
  })
5629
5626
  });
5630
- var DTODocumentationDraftStateDeleted = z201.object({
5631
- changeType: z201.literal(DTODocumentationDraftChangeType.enum.Deleted),
5632
- deletedAt: z201.coerce.date(),
5633
- deletedByUserId: z201.string()
5627
+ var DTODocumentationDraftStateDeleted = z202.object({
5628
+ changeType: z202.literal(DTODocumentationDraftChangeType.enum.Deleted),
5629
+ deletedAt: z202.coerce.date(),
5630
+ deletedByUserId: z202.string()
5634
5631
  });
5635
- var DTODocumentationDraftState = z201.discriminatedUnion("changeType", [
5632
+ var DTODocumentationDraftState = z202.discriminatedUnion("changeType", [
5636
5633
  DTODocumentationDraftStateCreated,
5637
5634
  DTODocumentationDraftStateUpdated,
5638
5635
  DTODocumentationDraftStateDeleted
5639
5636
  ]);
5640
5637
 
5641
5638
  // src/api/dto/elements/documentation/metadata.ts
5642
- import { z as z202 } from "zod";
5643
- var DTODocumentationPublishMetadata = z202.object({
5644
- lastPublishedByUserId: z202.string(),
5645
- lastPublishedAt: z202.coerce.date()
5639
+ import { z as z203 } from "zod";
5640
+ var DTODocumentationPublishMetadata = z203.object({
5641
+ lastPublishedByUserId: z203.string(),
5642
+ lastPublishedAt: z203.coerce.date()
5646
5643
  });
5647
5644
 
5648
5645
  // src/api/dto/elements/documentation/page-v2.ts
5649
- var DTODocumentationPageV2 = z203.object({
5650
- id: z203.string(),
5651
- persistentId: z203.string(),
5652
- designSystemVersionId: z203.string(),
5653
- title: z203.string(),
5646
+ var DTODocumentationPageV2 = z204.object({
5647
+ id: z204.string(),
5648
+ persistentId: z204.string(),
5649
+ designSystemVersionId: z204.string(),
5650
+ title: z204.string(),
5654
5651
  configuration: DTODocumentationItemConfigurationV2,
5655
- shortPersistentId: z203.string(),
5656
- slug: z203.string().optional(),
5657
- userSlug: z203.string().optional(),
5658
- createdAt: z203.coerce.date(),
5659
- updatedAt: z203.coerce.date(),
5660
- path: z203.string(),
5652
+ shortPersistentId: z204.string(),
5653
+ slug: z204.string().optional(),
5654
+ userSlug: z204.string().optional(),
5655
+ createdAt: z204.coerce.date(),
5656
+ updatedAt: z204.coerce.date(),
5657
+ path: z204.string(),
5661
5658
  /** Defined when a page has changed since last publish and can be included into a partial publish */
5662
5659
  draftState: DTODocumentationDraftState.optional(),
5663
5660
  /** Defined if a page was published at least once and contains metadata about last publish */
@@ -5665,197 +5662,197 @@ var DTODocumentationPageV2 = z203.object({
5665
5662
  /** Defines the approval state of the documentation page */
5666
5663
  approvalState: DTODocumentationPageApprovalState.optional(),
5667
5664
  // Backward compatibility
5668
- type: z203.literal("Page")
5665
+ type: z204.literal("Page")
5669
5666
  });
5670
- var DTOCreateDocumentationPageInputV2 = z203.object({
5667
+ var DTOCreateDocumentationPageInputV2 = z204.object({
5671
5668
  // Identifier
5672
- persistentId: z203.string().uuid(),
5669
+ persistentId: z204.string().uuid(),
5673
5670
  // Page properties
5674
- title: z203.string(),
5671
+ title: z204.string(),
5675
5672
  configuration: DTODocumentationItemConfigurationV2.partial().optional(),
5676
5673
  // Page placement properties
5677
- parentPersistentId: z203.string().uuid(),
5678
- afterPersistentId: z203.string().uuid().nullish()
5674
+ parentPersistentId: z204.string().uuid(),
5675
+ afterPersistentId: z204.string().uuid().nullish()
5679
5676
  });
5680
- var DTOUpdateDocumentationPageInputV2 = z203.object({
5677
+ var DTOUpdateDocumentationPageInputV2 = z204.object({
5681
5678
  // Identifier of the group to update
5682
- id: z203.string(),
5679
+ id: z204.string(),
5683
5680
  // Page properties
5684
- title: z203.string().optional(),
5681
+ title: z204.string().optional(),
5685
5682
  configuration: DTODocumentationItemConfigurationV2.partial().optional()
5686
5683
  });
5687
- var DTOMoveDocumentationPageInputV2 = z203.object({
5684
+ var DTOMoveDocumentationPageInputV2 = z204.object({
5688
5685
  // Identifier of the group to update
5689
- id: z203.string(),
5686
+ id: z204.string(),
5690
5687
  // Page placement properties
5691
- parentPersistentId: z203.string().uuid(),
5692
- afterPersistentId: z203.string().uuid().nullish()
5688
+ parentPersistentId: z204.string().uuid(),
5689
+ afterPersistentId: z204.string().uuid().nullish()
5693
5690
  });
5694
- var DTODuplicateDocumentationPageInputV2 = z203.object({
5691
+ var DTODuplicateDocumentationPageInputV2 = z204.object({
5695
5692
  // Identifier of the page to duplicate from
5696
- id: z203.string(),
5693
+ id: z204.string(),
5697
5694
  // New page persistent id
5698
- persistentId: z203.string().uuid(),
5695
+ persistentId: z204.string().uuid(),
5699
5696
  // Page placement properties
5700
- parentPersistentId: z203.string().uuid(),
5701
- afterPersistentId: z203.string().uuid().nullish()
5697
+ parentPersistentId: z204.string().uuid(),
5698
+ afterPersistentId: z204.string().uuid().nullish()
5702
5699
  });
5703
- var DTODeleteDocumentationPageInputV2 = z203.object({
5700
+ var DTODeleteDocumentationPageInputV2 = z204.object({
5704
5701
  // Identifier
5705
- id: z203.string()
5702
+ id: z204.string()
5706
5703
  });
5707
- var DTORestoreDocumentationPageInput = z203.object({
5708
- persistentId: z203.string(),
5709
- snapshotId: z203.string().optional()
5704
+ var DTORestoreDocumentationPageInput = z204.object({
5705
+ persistentId: z204.string(),
5706
+ snapshotId: z204.string().optional()
5710
5707
  });
5711
- var DTORestoreDocumentationGroupInput = z203.object({
5712
- persistentId: z203.string(),
5713
- snapshotId: z203.string().optional()
5708
+ var DTORestoreDocumentationGroupInput = z204.object({
5709
+ persistentId: z204.string(),
5710
+ snapshotId: z204.string().optional()
5714
5711
  });
5715
- var DTODocumentationPageApprovalStateChangeInput = z203.object({
5716
- persistentId: z203.string(),
5712
+ var DTODocumentationPageApprovalStateChangeInput = z204.object({
5713
+ persistentId: z204.string(),
5717
5714
  approvalState: DocumentationPageApprovalState.optional()
5718
5715
  });
5719
5716
 
5720
5717
  // src/api/dto/documentation/documentation-page-snapshot.ts
5721
- var DTODocumentationPageSnapshot = z204.object({
5722
- id: z204.string(),
5723
- designSystemVersionId: z204.string(),
5724
- createdAt: z204.string(),
5725
- updatedAt: z204.string(),
5718
+ var DTODocumentationPageSnapshot = z205.object({
5719
+ id: z205.string(),
5720
+ designSystemVersionId: z205.string(),
5721
+ createdAt: z205.string(),
5722
+ updatedAt: z205.string(),
5726
5723
  documentationPage: DTODocumentationPageV2,
5727
- pageContentHash: z204.string(),
5724
+ pageContentHash: z205.string(),
5728
5725
  reason: DesignElementSnapshotReason
5729
5726
  });
5730
5727
 
5731
5728
  // src/api/dto/documentation/link-preview.ts
5732
- import { z as z205 } from "zod";
5733
- var DTODocumentationLinkPreviewResponse = z205.object({
5729
+ import { z as z206 } from "zod";
5730
+ var DTODocumentationLinkPreviewResponse = z206.object({
5734
5731
  linkPreview: DocumentationLinkPreview
5735
5732
  });
5736
- var DTODocumentationLinkPreviewRequest = z205.object({
5737
- url: z205.string().optional(),
5738
- documentationItemPersistentId: z205.string().optional()
5733
+ var DTODocumentationLinkPreviewRequest = z206.object({
5734
+ url: z206.string().optional(),
5735
+ documentationItemPersistentId: z206.string().optional()
5739
5736
  });
5740
5737
 
5741
5738
  // src/api/dto/documentation/publish.ts
5742
- import { z as z209 } from "zod";
5739
+ import { z as z210 } from "zod";
5743
5740
 
5744
5741
  // src/api/dto/export/exporter.ts
5745
- import { z as z206 } from "zod";
5746
- var DTOExporterType = z206.enum(["documentation", "code"]);
5747
- var DTOExporterSource = z206.enum(["git", "upload"]);
5748
- var DTOExporterMembershipRole = z206.enum(["Owner", "OwnerArchived", "User"]);
5749
- var DTOExporter = z206.object({
5750
- id: z206.string(),
5751
- name: z206.string(),
5752
- isPrivate: z206.boolean(),
5742
+ import { z as z207 } from "zod";
5743
+ var DTOExporterType = z207.enum(["documentation", "code"]);
5744
+ var DTOExporterSource = z207.enum(["git", "upload"]);
5745
+ var DTOExporterMembershipRole = z207.enum(["Owner", "OwnerArchived", "User"]);
5746
+ var DTOExporter = z207.object({
5747
+ id: z207.string(),
5748
+ name: z207.string(),
5749
+ isPrivate: z207.boolean(),
5753
5750
  exporterType: DTOExporterType,
5754
- isDefaultDocumentationExporter: z206.boolean(),
5755
- iconURL: z206.string().optional(),
5751
+ isDefaultDocumentationExporter: z207.boolean(),
5752
+ iconURL: z207.string().optional(),
5756
5753
  configurationProperties: PulsarContributionConfigurationProperty.array(),
5757
5754
  customBlocks: PulsarCustomBlock.array(),
5758
- blockVariants: z206.record(z206.string(), PulsarContributionVariant.array()),
5759
- usesBrands: z206.boolean(),
5760
- usesThemes: z206.boolean(),
5755
+ blockVariants: z207.record(z207.string(), PulsarContributionVariant.array()),
5756
+ usesBrands: z207.boolean(),
5757
+ usesThemes: z207.boolean(),
5761
5758
  source: DTOExporterSource,
5762
- gitUrl: z206.string().optional(),
5763
- gitBranch: z206.string().optional(),
5764
- gitDirectory: z206.string().optional()
5759
+ gitUrl: z207.string().optional(),
5760
+ gitBranch: z207.string().optional(),
5761
+ gitDirectory: z207.string().optional()
5765
5762
  });
5766
- var DTOExporterMembership = z206.object({
5767
- workspaceId: z206.string(),
5768
- exporterId: z206.string(),
5763
+ var DTOExporterMembership = z207.object({
5764
+ workspaceId: z207.string(),
5765
+ exporterId: z207.string(),
5769
5766
  role: DTOExporterMembershipRole
5770
5767
  });
5771
- var DTOExporterCreateOutput = z206.object({
5768
+ var DTOExporterCreateOutput = z207.object({
5772
5769
  exporter: DTOExporter,
5773
5770
  membership: DTOExporterMembership
5774
5771
  });
5775
- var DTOExporterGitProviderEnum = z206.enum(["github", "gitlab", "bitbucket", "azure"]);
5776
- var DTOExporterCreateInput = z206.object({
5777
- url: z206.string(),
5772
+ var DTOExporterGitProviderEnum = z207.enum(["github", "gitlab", "bitbucket", "azure"]);
5773
+ var DTOExporterCreateInput = z207.object({
5774
+ url: z207.string(),
5778
5775
  provider: DTOExporterGitProviderEnum
5779
5776
  });
5780
- var DTOExporterUpdateInput = z206.object({
5781
- url: z206.string().optional()
5777
+ var DTOExporterUpdateInput = z207.object({
5778
+ url: z207.string().optional()
5782
5779
  });
5783
5780
 
5784
5781
  // src/api/dto/export/filter.ts
5785
5782
  var DTOExportJobsListFilter = ExportJobFindByFilter;
5786
5783
 
5787
5784
  // src/api/dto/export/job.ts
5788
- import { z as z207 } from "zod";
5789
- var DTOExportJobCreatedBy = z207.object({
5790
- userId: z207.string(),
5791
- userName: z207.string()
5785
+ import { z as z208 } from "zod";
5786
+ var DTOExportJobCreatedBy = z208.object({
5787
+ userId: z208.string(),
5788
+ userName: z208.string()
5792
5789
  });
5793
- var DTOExportJobDesignSystemPreview = z207.object({
5794
- id: z207.string(),
5790
+ var DTOExportJobDesignSystemPreview = z208.object({
5791
+ id: z208.string(),
5795
5792
  meta: ObjectMeta
5796
5793
  });
5797
- var DTOExportJobDesignSystemVersionPreview = z207.object({
5798
- id: z207.string(),
5794
+ var DTOExportJobDesignSystemVersionPreview = z208.object({
5795
+ id: z208.string(),
5799
5796
  meta: ObjectMeta,
5800
- version: z207.string(),
5801
- isReadonly: z207.boolean()
5797
+ version: z208.string(),
5798
+ isReadonly: z208.boolean()
5802
5799
  });
5803
- var DTOExportJobDestinations = z207.object({
5800
+ var DTOExportJobDestinations = z208.object({
5804
5801
  s3: ExporterDestinationS3.optional(),
5805
5802
  azure: ExporterDestinationAzure.optional(),
5806
5803
  bitbucket: ExporterDestinationBitbucket.optional(),
5807
5804
  github: ExporterDestinationGithub.optional(),
5808
5805
  gitlab: ExporterDestinationGitlab.optional(),
5809
5806
  documentation: ExporterDestinationDocs.optional(),
5810
- webhookUrl: z207.string().optional()
5807
+ webhookUrl: z208.string().optional()
5811
5808
  });
5812
5809
  var DTOExportJobResult = ExportJobResult.omit({
5813
5810
  sndocs: true
5814
5811
  }).extend({
5815
5812
  documentation: ExportJobDocsDestinationResult.optional()
5816
5813
  });
5817
- var DTOExportJob = z207.object({
5818
- id: z207.string(),
5819
- createdAt: z207.coerce.date(),
5820
- finishedAt: z207.coerce.date().optional(),
5821
- index: z207.number().optional(),
5814
+ var DTOExportJob = z208.object({
5815
+ id: z208.string(),
5816
+ createdAt: z208.coerce.date(),
5817
+ finishedAt: z208.coerce.date().optional(),
5818
+ index: z208.number().optional(),
5822
5819
  status: ExportJobStatus,
5823
- estimatedExecutionTime: z207.number().optional(),
5820
+ estimatedExecutionTime: z208.number().optional(),
5824
5821
  createdBy: DTOExportJobCreatedBy.optional(),
5825
5822
  designSystem: DTOExportJobDesignSystemPreview,
5826
5823
  designSystemVersion: DTOExportJobDesignSystemVersionPreview,
5827
5824
  destinations: DTOExportJobDestinations,
5828
- exporterId: z207.string(),
5829
- scheduleId: z207.string().optional(),
5825
+ exporterId: z208.string(),
5826
+ scheduleId: z208.string().optional(),
5830
5827
  result: DTOExportJobResult.optional(),
5831
- brandPersistentId: z207.string().optional(),
5832
- themePersistentId: z207.string().optional(),
5833
- themePersistentIds: z207.string().array().optional()
5828
+ brandPersistentId: z208.string().optional(),
5829
+ themePersistentId: z208.string().optional(),
5830
+ themePersistentIds: z208.string().array().optional()
5834
5831
  });
5835
- var DTOExportJobResponse = z207.object({
5832
+ var DTOExportJobResponse = z208.object({
5836
5833
  job: DTOExportJob
5837
5834
  });
5838
5835
 
5839
5836
  // src/api/dto/export/pipeline.ts
5840
- import { z as z208 } from "zod";
5841
- var DTOPipeline = z208.object({
5842
- id: z208.string(),
5843
- name: z208.string(),
5837
+ import { z as z209 } from "zod";
5838
+ var DTOPipeline = z209.object({
5839
+ id: z209.string(),
5840
+ name: z209.string(),
5844
5841
  eventType: PipelineEventType,
5845
- isEnabled: z208.boolean(),
5846
- workspaceId: z208.string(),
5847
- designSystemId: z208.string(),
5848
- exporterId: z208.string(),
5849
- brandPersistentId: z208.string().optional(),
5850
- themePersistentId: z208.string().optional(),
5851
- themePersistentIds: z208.string().array().optional(),
5842
+ isEnabled: z209.boolean(),
5843
+ workspaceId: z209.string(),
5844
+ designSystemId: z209.string(),
5845
+ exporterId: z209.string(),
5846
+ brandPersistentId: z209.string().optional(),
5847
+ themePersistentId: z209.string().optional(),
5848
+ themePersistentIds: z209.string().array().optional(),
5852
5849
  ...ExportDestinationsMap.shape,
5853
5850
  latestJobs: DTOExportJob.array()
5854
5851
  });
5855
5852
 
5856
5853
  // src/api/dto/documentation/publish.ts
5857
5854
  var DTOPublishDocumentationChanges = ExportJobDocumentationChanges;
5858
- var DTOPublishDocumentationRequest = z209.object({
5855
+ var DTOPublishDocumentationRequest = z210.object({
5859
5856
  environment: PublishedDocEnvironment,
5860
5857
  /**
5861
5858
  * If defined, this allows narrowing down what is published to a set of specific pages and groups
@@ -5863,42 +5860,42 @@ var DTOPublishDocumentationRequest = z209.object({
5863
5860
  */
5864
5861
  changes: DTOPublishDocumentationChanges.optional()
5865
5862
  });
5866
- var DTOPublishDocumentationResponse = z209.object({
5863
+ var DTOPublishDocumentationResponse = z210.object({
5867
5864
  job: DTOExportJob
5868
5865
  });
5869
5866
 
5870
5867
  // src/api/dto/elements/components/figma-component.ts
5871
- import { z as z210 } from "zod";
5868
+ import { z as z211 } from "zod";
5872
5869
  var DTOFigmaComponentProperty = FigmaComponentProperty;
5873
- var DTOFigmaComponentPropertyMap = z210.record(DTOFigmaComponentProperty);
5874
- var DTOFigmaComponent = z210.object({
5875
- id: z210.string(),
5876
- persistentId: z210.string(),
5877
- designSystemVersionId: z210.string(),
5878
- brandId: z210.string(),
5879
- thumbnailUrl: z210.string().optional(),
5880
- svgUrl: z210.string().optional(),
5881
- exportProperties: z210.object({
5882
- isAsset: z210.boolean()
5870
+ var DTOFigmaComponentPropertyMap = z211.record(DTOFigmaComponentProperty);
5871
+ var DTOFigmaComponent = z211.object({
5872
+ id: z211.string(),
5873
+ persistentId: z211.string(),
5874
+ designSystemVersionId: z211.string(),
5875
+ brandId: z211.string(),
5876
+ thumbnailUrl: z211.string().optional(),
5877
+ svgUrl: z211.string().optional(),
5878
+ exportProperties: z211.object({
5879
+ isAsset: z211.boolean()
5883
5880
  }),
5884
- createdAt: z210.coerce.date(),
5885
- updatedAt: z210.coerce.date(),
5881
+ createdAt: z211.coerce.date(),
5882
+ updatedAt: z211.coerce.date(),
5886
5883
  meta: ObjectMeta,
5887
5884
  originComponent: FigmaComponentOrigin.optional(),
5888
- parentComponentPersistentId: z210.string().optional(),
5889
- childrenPersistentIds: z210.string().array().optional(),
5885
+ parentComponentPersistentId: z211.string().optional(),
5886
+ childrenPersistentIds: z211.string().array().optional(),
5890
5887
  componentPropertyDefinitions: DTOFigmaComponentPropertyMap.optional(),
5891
- variantPropertyValues: z210.record(z210.string()).optional()
5888
+ variantPropertyValues: z211.record(z211.string()).optional()
5892
5889
  });
5893
- var DTOFigmaComponentListResponse = z210.object({
5890
+ var DTOFigmaComponentListResponse = z211.object({
5894
5891
  components: DTOFigmaComponent.array()
5895
5892
  });
5896
5893
 
5897
5894
  // src/api/dto/elements/documentation/group-action.ts
5898
- import { z as z212 } from "zod";
5895
+ import { z as z213 } from "zod";
5899
5896
 
5900
5897
  // src/api/dto/elements/documentation/group-v2.ts
5901
- import { z as z211 } from "zod";
5898
+ import { z as z212 } from "zod";
5902
5899
  var DTODocumentationGroupV2 = ElementGroup.omit({
5903
5900
  sortOrder: true,
5904
5901
  parentPersistentId: true,
@@ -5908,13 +5905,13 @@ var DTODocumentationGroupV2 = ElementGroup.omit({
5908
5905
  data: true,
5909
5906
  shortPersistentId: true
5910
5907
  }).extend({
5911
- title: z211.string(),
5912
- isRoot: z211.boolean(),
5913
- childrenIds: z211.array(z211.string()),
5908
+ title: z212.string(),
5909
+ isRoot: z212.boolean(),
5910
+ childrenIds: z212.array(z212.string()),
5914
5911
  groupBehavior: DocumentationGroupBehavior,
5915
- shortPersistentId: z211.string(),
5912
+ shortPersistentId: z212.string(),
5916
5913
  configuration: DTODocumentationItemConfigurationV2,
5917
- type: z211.literal("Group"),
5914
+ type: z212.literal("Group"),
5918
5915
  /** Defined when a group has changed since last publish and can be included into a partial publish */
5919
5916
  draftState: DTODocumentationDraftState.optional(),
5920
5917
  /** Defined if a group was published at least once and contains metadata about last publish */
@@ -5922,127 +5919,127 @@ var DTODocumentationGroupV2 = ElementGroup.omit({
5922
5919
  //** An approval state for frontend to utilize. */
5923
5920
  approvalState: DTODocumentationGroupApprovalState.optional()
5924
5921
  });
5925
- var DTOCreateDocumentationGroupInput = z211.object({
5922
+ var DTOCreateDocumentationGroupInput = z212.object({
5926
5923
  // Identifier
5927
- persistentId: z211.string().uuid(),
5924
+ persistentId: z212.string().uuid(),
5928
5925
  // Group properties
5929
- title: z211.string(),
5926
+ title: z212.string(),
5930
5927
  configuration: DTODocumentationItemConfigurationV2.partial().optional(),
5931
5928
  // Group placement properties
5932
- afterPersistentId: z211.string().uuid().nullish(),
5933
- parentPersistentId: z211.string().uuid()
5929
+ afterPersistentId: z212.string().uuid().nullish(),
5930
+ parentPersistentId: z212.string().uuid()
5934
5931
  });
5935
- var DTOUpdateDocumentationGroupInput = z211.object({
5932
+ var DTOUpdateDocumentationGroupInput = z212.object({
5936
5933
  // Identifier of the group to update
5937
- id: z211.string(),
5934
+ id: z212.string(),
5938
5935
  // Group properties
5939
- title: z211.string().optional(),
5936
+ title: z212.string().optional(),
5940
5937
  configuration: DTODocumentationItemConfigurationV2.partial().optional()
5941
5938
  });
5942
- var DTOMoveDocumentationGroupInput = z211.object({
5939
+ var DTOMoveDocumentationGroupInput = z212.object({
5943
5940
  // Identifier of the group to update
5944
- id: z211.string(),
5941
+ id: z212.string(),
5945
5942
  // Group placement properties
5946
- parentPersistentId: z211.string().uuid(),
5947
- afterPersistentId: z211.string().uuid().nullish()
5943
+ parentPersistentId: z212.string().uuid(),
5944
+ afterPersistentId: z212.string().uuid().nullish()
5948
5945
  });
5949
- var DTODuplicateDocumentationGroupInput = z211.object({
5946
+ var DTODuplicateDocumentationGroupInput = z212.object({
5950
5947
  // Identifier of the group to duplicate from
5951
- id: z211.string(),
5948
+ id: z212.string(),
5952
5949
  // New group persistent id
5953
- persistentId: z211.string().uuid(),
5950
+ persistentId: z212.string().uuid(),
5954
5951
  // Group placement properties
5955
- afterPersistentId: z211.string().uuid().nullish(),
5956
- parentPersistentId: z211.string().uuid()
5952
+ afterPersistentId: z212.string().uuid().nullish(),
5953
+ parentPersistentId: z212.string().uuid()
5957
5954
  });
5958
- var DTOCreateDocumentationTabInput = z211.object({
5955
+ var DTOCreateDocumentationTabInput = z212.object({
5959
5956
  // New group persistent id
5960
- persistentId: z211.string().uuid(),
5957
+ persistentId: z212.string().uuid(),
5961
5958
  // If this is page, we will attempt to convert it to tab
5962
5959
  // If this is tab group, we will add a new tab to it
5963
- fromItemPersistentId: z211.string(),
5964
- tabName: z211.string()
5960
+ fromItemPersistentId: z212.string(),
5961
+ tabName: z212.string()
5965
5962
  });
5966
- var DTODeleteDocumentationTabGroupInput = z211.object({
5963
+ var DTODeleteDocumentationTabGroupInput = z212.object({
5967
5964
  // Deleted group id
5968
- id: z211.string()
5965
+ id: z212.string()
5969
5966
  });
5970
- var DTODeleteDocumentationGroupInput = z211.object({
5967
+ var DTODeleteDocumentationGroupInput = z212.object({
5971
5968
  // Identifier
5972
- id: z211.string(),
5969
+ id: z212.string(),
5973
5970
  // Deletion options
5974
- deleteSubtree: z211.boolean().default(false)
5971
+ deleteSubtree: z212.boolean().default(false)
5975
5972
  });
5976
5973
 
5977
5974
  // src/api/dto/elements/documentation/group-action.ts
5978
- var SuccessPayload = z212.object({
5979
- success: z212.literal(true)
5975
+ var SuccessPayload = z213.object({
5976
+ success: z213.literal(true)
5980
5977
  });
5981
- var DTODocumentationGroupCreateActionOutputV2 = z212.object({
5982
- type: z212.literal("DocumentationGroupCreate"),
5978
+ var DTODocumentationGroupCreateActionOutputV2 = z213.object({
5979
+ type: z213.literal("DocumentationGroupCreate"),
5983
5980
  output: SuccessPayload
5984
5981
  });
5985
- var DTODocumentationTabCreateActionOutputV2 = z212.object({
5986
- type: z212.literal("DocumentationTabCreate"),
5982
+ var DTODocumentationTabCreateActionOutputV2 = z213.object({
5983
+ type: z213.literal("DocumentationTabCreate"),
5987
5984
  output: SuccessPayload
5988
5985
  });
5989
- var DTODocumentationGroupUpdateActionOutputV2 = z212.object({
5990
- type: z212.literal("DocumentationGroupUpdate"),
5986
+ var DTODocumentationGroupUpdateActionOutputV2 = z213.object({
5987
+ type: z213.literal("DocumentationGroupUpdate"),
5991
5988
  output: SuccessPayload
5992
5989
  });
5993
- var DTODocumentationGroupMoveActionOutputV2 = z212.object({
5994
- type: z212.literal("DocumentationGroupMove"),
5990
+ var DTODocumentationGroupMoveActionOutputV2 = z213.object({
5991
+ type: z213.literal("DocumentationGroupMove"),
5995
5992
  output: SuccessPayload
5996
5993
  });
5997
- var DTODocumentationGroupDuplicateActionOutputV2 = z212.object({
5998
- type: z212.literal("DocumentationGroupDuplicate"),
5994
+ var DTODocumentationGroupDuplicateActionOutputV2 = z213.object({
5995
+ type: z213.literal("DocumentationGroupDuplicate"),
5999
5996
  output: SuccessPayload
6000
5997
  });
6001
- var DTODocumentationGroupDeleteActionOutputV2 = z212.object({
6002
- type: z212.literal("DocumentationGroupDelete"),
5998
+ var DTODocumentationGroupDeleteActionOutputV2 = z213.object({
5999
+ type: z213.literal("DocumentationGroupDelete"),
6003
6000
  output: SuccessPayload
6004
6001
  });
6005
- var DTODocumentationTabGroupDeleteActionOutputV2 = z212.object({
6006
- type: z212.literal("DocumentationTabGroupDelete"),
6002
+ var DTODocumentationTabGroupDeleteActionOutputV2 = z213.object({
6003
+ type: z213.literal("DocumentationTabGroupDelete"),
6007
6004
  output: SuccessPayload
6008
6005
  });
6009
- var DTODocumentationGroupCreateActionInputV2 = z212.object({
6010
- type: z212.literal("DocumentationGroupCreate"),
6006
+ var DTODocumentationGroupCreateActionInputV2 = z213.object({
6007
+ type: z213.literal("DocumentationGroupCreate"),
6011
6008
  input: DTOCreateDocumentationGroupInput
6012
6009
  });
6013
- var DTODocumentationTabCreateActionInputV2 = z212.object({
6014
- type: z212.literal("DocumentationTabCreate"),
6010
+ var DTODocumentationTabCreateActionInputV2 = z213.object({
6011
+ type: z213.literal("DocumentationTabCreate"),
6015
6012
  input: DTOCreateDocumentationTabInput
6016
6013
  });
6017
- var DTODocumentationGroupUpdateActionInputV2 = z212.object({
6018
- type: z212.literal("DocumentationGroupUpdate"),
6014
+ var DTODocumentationGroupUpdateActionInputV2 = z213.object({
6015
+ type: z213.literal("DocumentationGroupUpdate"),
6019
6016
  input: DTOUpdateDocumentationGroupInput
6020
6017
  });
6021
- var DTODocumentationGroupMoveActionInputV2 = z212.object({
6022
- type: z212.literal("DocumentationGroupMove"),
6018
+ var DTODocumentationGroupMoveActionInputV2 = z213.object({
6019
+ type: z213.literal("DocumentationGroupMove"),
6023
6020
  input: DTOMoveDocumentationGroupInput
6024
6021
  });
6025
- var DTODocumentationGroupDuplicateActionInputV2 = z212.object({
6026
- type: z212.literal("DocumentationGroupDuplicate"),
6022
+ var DTODocumentationGroupDuplicateActionInputV2 = z213.object({
6023
+ type: z213.literal("DocumentationGroupDuplicate"),
6027
6024
  input: DTODuplicateDocumentationGroupInput
6028
6025
  });
6029
- var DTODocumentationGroupDeleteActionInputV2 = z212.object({
6030
- type: z212.literal("DocumentationGroupDelete"),
6026
+ var DTODocumentationGroupDeleteActionInputV2 = z213.object({
6027
+ type: z213.literal("DocumentationGroupDelete"),
6031
6028
  input: DTODeleteDocumentationGroupInput
6032
6029
  });
6033
- var DTODocumentationTabGroupDeleteActionInputV2 = z212.object({
6034
- type: z212.literal("DocumentationTabGroupDelete"),
6030
+ var DTODocumentationTabGroupDeleteActionInputV2 = z213.object({
6031
+ type: z213.literal("DocumentationTabGroupDelete"),
6035
6032
  input: DTODeleteDocumentationTabGroupInput
6036
6033
  });
6037
6034
 
6038
6035
  // src/api/dto/elements/documentation/group-v1.ts
6039
- import { z as z214 } from "zod";
6036
+ import { z as z215 } from "zod";
6040
6037
 
6041
6038
  // src/api/dto/elements/documentation/item-configuration-v1.ts
6042
- import { z as z213 } from "zod";
6043
- var DocumentationColorV1 = z213.object({
6044
- aliasTo: z213.string().optional(),
6045
- value: z213.string().optional()
6039
+ import { z as z214 } from "zod";
6040
+ var DocumentationColorV1 = z214.object({
6041
+ aliasTo: z214.string().optional(),
6042
+ value: z214.string().optional()
6046
6043
  });
6047
6044
  var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
6048
6045
  foregroundColor: true,
@@ -6051,10 +6048,10 @@ var DTODocumentationItemHeaderV1 = DocumentationItemHeaderV1.omit({
6051
6048
  foregroundColor: DocumentationColorV1.optional(),
6052
6049
  backgroundColor: DocumentationColorV1.optional()
6053
6050
  });
6054
- var DTODocumentationItemConfigurationV1 = z213.object({
6055
- showSidebar: z213.boolean(),
6056
- isPrivate: z213.boolean(),
6057
- isHidden: z213.boolean(),
6051
+ var DTODocumentationItemConfigurationV1 = z214.object({
6052
+ showSidebar: z214.boolean(),
6053
+ isPrivate: z214.boolean(),
6054
+ isHidden: z214.boolean(),
6058
6055
  header: DTODocumentationItemHeaderV1
6059
6056
  });
6060
6057
 
@@ -6068,27 +6065,27 @@ var DTODocumentationGroupStructureV1 = ElementGroup.omit({
6068
6065
  data: true,
6069
6066
  shortPersistentId: true
6070
6067
  }).extend({
6071
- title: z214.string(),
6072
- isRoot: z214.boolean(),
6073
- childrenIds: z214.array(z214.string()),
6068
+ title: z215.string(),
6069
+ isRoot: z215.boolean(),
6070
+ childrenIds: z215.array(z215.string()),
6074
6071
  groupBehavior: DocumentationGroupBehavior,
6075
- shortPersistentId: z214.string(),
6076
- type: z214.literal("Group")
6072
+ shortPersistentId: z215.string(),
6073
+ type: z215.literal("Group")
6077
6074
  });
6078
6075
  var DTODocumentationGroupV1 = DTODocumentationGroupStructureV1.extend({
6079
6076
  configuration: DTODocumentationItemConfigurationV1
6080
6077
  });
6081
6078
 
6082
6079
  // src/api/dto/elements/documentation/hierarchy.ts
6083
- import { z as z215 } from "zod";
6084
- var DTODocumentationHierarchyV2 = z215.object({
6085
- pages: z215.array(
6080
+ import { z as z216 } from "zod";
6081
+ var DTODocumentationHierarchyV2 = z216.object({
6082
+ pages: z216.array(
6086
6083
  DTODocumentationPageV2.extend({
6087
6084
  /** Defined when a page has changed since last publish and can be included into a partial publish */
6088
6085
  draftState: DTODocumentationDraftState.optional()
6089
6086
  })
6090
6087
  ),
6091
- groups: z215.array(
6088
+ groups: z216.array(
6092
6089
  DTODocumentationGroupV2.extend({
6093
6090
  /** Defined when a page has changed since last publish and can be included into a partial publish */
6094
6091
  draftState: DTODocumentationDraftState.optional()
@@ -6097,84 +6094,84 @@ var DTODocumentationHierarchyV2 = z215.object({
6097
6094
  });
6098
6095
 
6099
6096
  // src/api/dto/elements/documentation/page-actions-v2.ts
6100
- import { z as z216 } from "zod";
6101
- var SuccessPayload2 = z216.object({
6102
- success: z216.literal(true)
6097
+ import { z as z217 } from "zod";
6098
+ var SuccessPayload2 = z217.object({
6099
+ success: z217.literal(true)
6103
6100
  });
6104
- var DTODocumentationPageCreateActionOutputV2 = z216.object({
6105
- type: z216.literal("DocumentationPageCreate"),
6101
+ var DTODocumentationPageCreateActionOutputV2 = z217.object({
6102
+ type: z217.literal("DocumentationPageCreate"),
6106
6103
  output: SuccessPayload2
6107
6104
  });
6108
- var DTODocumentationPageUpdateActionOutputV2 = z216.object({
6109
- type: z216.literal("DocumentationPageUpdate"),
6105
+ var DTODocumentationPageUpdateActionOutputV2 = z217.object({
6106
+ type: z217.literal("DocumentationPageUpdate"),
6110
6107
  output: SuccessPayload2
6111
6108
  });
6112
- var DTODocumentationPageMoveActionOutputV2 = z216.object({
6113
- type: z216.literal("DocumentationPageMove"),
6109
+ var DTODocumentationPageMoveActionOutputV2 = z217.object({
6110
+ type: z217.literal("DocumentationPageMove"),
6114
6111
  output: SuccessPayload2
6115
6112
  });
6116
- var DTODocumentationPageDuplicateActionOutputV2 = z216.object({
6117
- type: z216.literal("DocumentationPageDuplicate"),
6113
+ var DTODocumentationPageDuplicateActionOutputV2 = z217.object({
6114
+ type: z217.literal("DocumentationPageDuplicate"),
6118
6115
  output: SuccessPayload2
6119
6116
  });
6120
- var DTODocumentationPageDeleteActionOutputV2 = z216.object({
6121
- type: z216.literal("DocumentationPageDelete"),
6117
+ var DTODocumentationPageDeleteActionOutputV2 = z217.object({
6118
+ type: z217.literal("DocumentationPageDelete"),
6122
6119
  output: SuccessPayload2
6123
6120
  });
6124
- var DTODocumentationPageRestoreActionOutput = z216.object({
6125
- type: z216.literal("DocumentationPageRestore"),
6121
+ var DTODocumentationPageRestoreActionOutput = z217.object({
6122
+ type: z217.literal("DocumentationPageRestore"),
6126
6123
  output: SuccessPayload2
6127
6124
  });
6128
- var DTODocumentationGroupRestoreActionOutput = z216.object({
6129
- type: z216.literal("DocumentationGroupRestore"),
6125
+ var DTODocumentationGroupRestoreActionOutput = z217.object({
6126
+ type: z217.literal("DocumentationGroupRestore"),
6130
6127
  output: SuccessPayload2
6131
6128
  });
6132
- var DTODocumentationPageApprovalStateChangeActionOutput = z216.object({
6133
- type: z216.literal("DocumentationPageApprovalStateChange"),
6129
+ var DTODocumentationPageApprovalStateChangeActionOutput = z217.object({
6130
+ type: z217.literal("DocumentationPageApprovalStateChange"),
6134
6131
  output: SuccessPayload2
6135
6132
  });
6136
- var DTODocumentationPageCreateActionInputV2 = z216.object({
6137
- type: z216.literal("DocumentationPageCreate"),
6133
+ var DTODocumentationPageCreateActionInputV2 = z217.object({
6134
+ type: z217.literal("DocumentationPageCreate"),
6138
6135
  input: DTOCreateDocumentationPageInputV2
6139
6136
  });
6140
- var DTODocumentationPageUpdateActionInputV2 = z216.object({
6141
- type: z216.literal("DocumentationPageUpdate"),
6137
+ var DTODocumentationPageUpdateActionInputV2 = z217.object({
6138
+ type: z217.literal("DocumentationPageUpdate"),
6142
6139
  input: DTOUpdateDocumentationPageInputV2
6143
6140
  });
6144
- var DTODocumentationPageMoveActionInputV2 = z216.object({
6145
- type: z216.literal("DocumentationPageMove"),
6141
+ var DTODocumentationPageMoveActionInputV2 = z217.object({
6142
+ type: z217.literal("DocumentationPageMove"),
6146
6143
  input: DTOMoveDocumentationPageInputV2
6147
6144
  });
6148
- var DTODocumentationPageDuplicateActionInputV2 = z216.object({
6149
- type: z216.literal("DocumentationPageDuplicate"),
6145
+ var DTODocumentationPageDuplicateActionInputV2 = z217.object({
6146
+ type: z217.literal("DocumentationPageDuplicate"),
6150
6147
  input: DTODuplicateDocumentationPageInputV2
6151
6148
  });
6152
- var DTODocumentationPageDeleteActionInputV2 = z216.object({
6153
- type: z216.literal("DocumentationPageDelete"),
6149
+ var DTODocumentationPageDeleteActionInputV2 = z217.object({
6150
+ type: z217.literal("DocumentationPageDelete"),
6154
6151
  input: DTODeleteDocumentationPageInputV2
6155
6152
  });
6156
- var DTODocumentationPageRestoreActionInput = z216.object({
6157
- type: z216.literal("DocumentationPageRestore"),
6153
+ var DTODocumentationPageRestoreActionInput = z217.object({
6154
+ type: z217.literal("DocumentationPageRestore"),
6158
6155
  input: DTORestoreDocumentationPageInput
6159
6156
  });
6160
- var DTODocumentationGroupRestoreActionInput = z216.object({
6161
- type: z216.literal("DocumentationGroupRestore"),
6157
+ var DTODocumentationGroupRestoreActionInput = z217.object({
6158
+ type: z217.literal("DocumentationGroupRestore"),
6162
6159
  input: DTORestoreDocumentationGroupInput
6163
6160
  });
6164
- var DTODocumentationPageApprovalStateChangeActionInput = z216.object({
6165
- type: z216.literal("DocumentationPageApprovalStateChange"),
6161
+ var DTODocumentationPageApprovalStateChangeActionInput = z217.object({
6162
+ type: z217.literal("DocumentationPageApprovalStateChange"),
6166
6163
  input: DTODocumentationPageApprovalStateChangeInput
6167
6164
  });
6168
6165
 
6169
6166
  // src/api/dto/elements/documentation/page-content.ts
6170
- import { z as z217 } from "zod";
6167
+ import { z as z218 } from "zod";
6171
6168
  var DTODocumentationPageContent = DocumentationPageContent;
6172
- var DTODocumentationPageContentGetResponse = z217.object({
6169
+ var DTODocumentationPageContentGetResponse = z218.object({
6173
6170
  pageContent: DTODocumentationPageContent
6174
6171
  });
6175
6172
 
6176
6173
  // src/api/dto/elements/documentation/page-v1.ts
6177
- import { z as z218 } from "zod";
6174
+ import { z as z219 } from "zod";
6178
6175
  var DocumentationPageV1DTO = DocumentationPageV1.omit({
6179
6176
  data: true,
6180
6177
  meta: true,
@@ -6182,32 +6179,32 @@ var DocumentationPageV1DTO = DocumentationPageV1.omit({
6182
6179
  sortOrder: true
6183
6180
  }).extend({
6184
6181
  configuration: DTODocumentationItemConfigurationV1,
6185
- blocks: z218.array(PageBlockV1),
6186
- title: z218.string(),
6187
- path: z218.string()
6182
+ blocks: z219.array(PageBlockV1),
6183
+ title: z219.string(),
6184
+ path: z219.string()
6188
6185
  });
6189
6186
 
6190
6187
  // src/api/dto/elements/figma-nodes/figma-node.ts
6191
- import { z as z219 } from "zod";
6188
+ import { z as z220 } from "zod";
6192
6189
  var DTOFigmaNodeRenderFormat = FigmaNodeRenderFormat;
6193
- var DTOFigmaNodeOrigin = z219.object({
6194
- sourceId: z219.string(),
6195
- fileId: z219.string().optional(),
6196
- parentName: z219.string().optional()
6190
+ var DTOFigmaNodeOrigin = z220.object({
6191
+ sourceId: z220.string(),
6192
+ fileId: z220.string().optional(),
6193
+ parentName: z220.string().optional()
6197
6194
  });
6198
- var DTOFigmaNodeData = z219.object({
6195
+ var DTOFigmaNodeData = z220.object({
6199
6196
  // Id of the node in the Figma file
6200
- figmaNodeId: z219.string(),
6197
+ figmaNodeId: z220.string(),
6201
6198
  // Validity
6202
- isValid: z219.boolean(),
6199
+ isValid: z220.boolean(),
6203
6200
  // Asset data
6204
- assetId: z219.string(),
6205
- assetUrl: z219.string(),
6201
+ assetId: z220.string(),
6202
+ assetUrl: z220.string(),
6206
6203
  assetFormat: DTOFigmaNodeRenderFormat,
6207
6204
  // Asset metadata
6208
- assetScale: z219.number(),
6209
- assetWidth: z219.number().optional(),
6210
- assetHeight: z219.number().optional()
6205
+ assetScale: z220.number(),
6206
+ assetWidth: z220.number().optional(),
6207
+ assetHeight: z220.number().optional()
6211
6208
  });
6212
6209
  var DTOFigmaNode = FigmaNodeReference.omit({
6213
6210
  data: true,
@@ -6216,15 +6213,15 @@ var DTOFigmaNode = FigmaNodeReference.omit({
6216
6213
  data: DTOFigmaNodeData,
6217
6214
  origin: DTOFigmaNodeOrigin
6218
6215
  });
6219
- var DTOFigmaNodeRenderInput = z219.object({
6216
+ var DTOFigmaNodeRenderInput = z220.object({
6220
6217
  /**
6221
6218
  * Id of a design system's data source representing a linked Figma file
6222
6219
  */
6223
- sourceId: z219.string(),
6220
+ sourceId: z220.string(),
6224
6221
  /**
6225
6222
  * Id of a node within the Figma file
6226
6223
  */
6227
- figmaFileNodeId: z219.string(),
6224
+ figmaFileNodeId: z220.string(),
6228
6225
  /**
6229
6226
  * Format in which the node must be rendered, png by default.
6230
6227
  */
@@ -6232,97 +6229,97 @@ var DTOFigmaNodeRenderInput = z219.object({
6232
6229
  });
6233
6230
 
6234
6231
  // src/api/dto/elements/figma-nodes/node-actions-v2.ts
6235
- import { z as z220 } from "zod";
6236
- var DTOFigmaNodeRenderActionOutput = z220.object({
6237
- type: z220.literal("FigmaNodeRender"),
6238
- figmaNodes: z220.array(DTOFigmaNode)
6232
+ import { z as z221 } from "zod";
6233
+ var DTOFigmaNodeRenderActionOutput = z221.object({
6234
+ type: z221.literal("FigmaNodeRender"),
6235
+ figmaNodes: z221.array(DTOFigmaNode)
6239
6236
  });
6240
- var DTOFigmaNodeRenderActionInput = z220.object({
6241
- type: z220.literal("FigmaNodeRender"),
6237
+ var DTOFigmaNodeRenderActionInput = z221.object({
6238
+ type: z221.literal("FigmaNodeRender"),
6242
6239
  input: DTOFigmaNodeRenderInput.array()
6243
6240
  });
6244
6241
 
6245
6242
  // src/api/dto/elements/properties/property-definitions-actions-v2.ts
6246
- import { z as z222 } from "zod";
6243
+ import { z as z223 } from "zod";
6247
6244
 
6248
6245
  // src/api/dto/elements/properties/property-definitions.ts
6249
- import { z as z221 } from "zod";
6246
+ import { z as z222 } from "zod";
6250
6247
  var CODE_NAME_REGEX2 = /^[a-zA-Z_$][a-zA-Z_$0-9]{1,99}$/;
6251
- var DTOElementPropertyDefinition = z221.object({
6252
- id: z221.string(),
6253
- designSystemVersionId: z221.string(),
6248
+ var DTOElementPropertyDefinition = z222.object({
6249
+ id: z222.string(),
6250
+ designSystemVersionId: z222.string(),
6254
6251
  meta: ObjectMeta,
6255
- persistentId: z221.string(),
6252
+ persistentId: z222.string(),
6256
6253
  type: ElementPropertyTypeSchema,
6257
6254
  targetElementType: ElementPropertyTargetType,
6258
- codeName: z221.string().regex(CODE_NAME_REGEX2),
6259
- options: z221.array(ElementPropertyDefinitionOption).optional(),
6255
+ codeName: z222.string().regex(CODE_NAME_REGEX2),
6256
+ options: z222.array(ElementPropertyDefinitionOption).optional(),
6260
6257
  linkElementType: ElementPropertyLinkType.optional()
6261
6258
  });
6262
- var DTOElementPropertyDefinitionsGetResponse = z221.object({
6263
- definitions: z221.array(DTOElementPropertyDefinition)
6259
+ var DTOElementPropertyDefinitionsGetResponse = z222.object({
6260
+ definitions: z222.array(DTOElementPropertyDefinition)
6264
6261
  });
6265
6262
  var DTOCreateElementPropertyDefinitionInputV2 = DTOElementPropertyDefinition.omit({
6266
6263
  id: true,
6267
6264
  designSystemVersionId: true
6268
6265
  });
6269
- var DTOUpdateElementPropertyDefinitionInputV2 = z221.object({
6270
- id: z221.string(),
6271
- name: z221.string().optional(),
6272
- description: z221.string().optional(),
6273
- codeName: z221.string().regex(CODE_NAME_REGEX2).optional(),
6274
- options: z221.array(ElementPropertyDefinitionOption).optional()
6266
+ var DTOUpdateElementPropertyDefinitionInputV2 = z222.object({
6267
+ id: z222.string(),
6268
+ name: z222.string().optional(),
6269
+ description: z222.string().optional(),
6270
+ codeName: z222.string().regex(CODE_NAME_REGEX2).optional(),
6271
+ options: z222.array(ElementPropertyDefinitionOption).optional()
6275
6272
  });
6276
- var DTODeleteElementPropertyDefinitionInputV2 = z221.object({
6277
- id: z221.string()
6273
+ var DTODeleteElementPropertyDefinitionInputV2 = z222.object({
6274
+ id: z222.string()
6278
6275
  });
6279
6276
 
6280
6277
  // src/api/dto/elements/properties/property-definitions-actions-v2.ts
6281
- var SuccessPayload3 = z222.object({
6282
- success: z222.literal(true)
6278
+ var SuccessPayload3 = z223.object({
6279
+ success: z223.literal(true)
6283
6280
  });
6284
- var DTOPropertyDefinitionCreateActionOutputV2 = z222.object({
6285
- type: z222.literal("PropertyDefinitionCreate"),
6281
+ var DTOPropertyDefinitionCreateActionOutputV2 = z223.object({
6282
+ type: z223.literal("PropertyDefinitionCreate"),
6286
6283
  definition: DTOElementPropertyDefinition
6287
6284
  });
6288
- var DTOPropertyDefinitionUpdateActionOutputV2 = z222.object({
6289
- type: z222.literal("PropertyDefinitionUpdate"),
6285
+ var DTOPropertyDefinitionUpdateActionOutputV2 = z223.object({
6286
+ type: z223.literal("PropertyDefinitionUpdate"),
6290
6287
  definition: DTOElementPropertyDefinition
6291
6288
  });
6292
- var DTOPropertyDefinitionDeleteActionOutputV2 = z222.object({
6293
- type: z222.literal("PropertyDefinitionDelete"),
6289
+ var DTOPropertyDefinitionDeleteActionOutputV2 = z223.object({
6290
+ type: z223.literal("PropertyDefinitionDelete"),
6294
6291
  output: SuccessPayload3
6295
6292
  });
6296
- var DTOPropertyDefinitionCreateActionInputV2 = z222.object({
6297
- type: z222.literal("PropertyDefinitionCreate"),
6293
+ var DTOPropertyDefinitionCreateActionInputV2 = z223.object({
6294
+ type: z223.literal("PropertyDefinitionCreate"),
6298
6295
  input: DTOCreateElementPropertyDefinitionInputV2
6299
6296
  });
6300
- var DTOPropertyDefinitionUpdateActionInputV2 = z222.object({
6301
- type: z222.literal("PropertyDefinitionUpdate"),
6297
+ var DTOPropertyDefinitionUpdateActionInputV2 = z223.object({
6298
+ type: z223.literal("PropertyDefinitionUpdate"),
6302
6299
  input: DTOUpdateElementPropertyDefinitionInputV2
6303
6300
  });
6304
- var DTOPropertyDefinitionDeleteActionInputV2 = z222.object({
6305
- type: z222.literal("PropertyDefinitionDelete"),
6301
+ var DTOPropertyDefinitionDeleteActionInputV2 = z223.object({
6302
+ type: z223.literal("PropertyDefinitionDelete"),
6306
6303
  input: DTODeleteElementPropertyDefinitionInputV2
6307
6304
  });
6308
6305
 
6309
6306
  // src/api/dto/elements/properties/property-values.ts
6310
- import { z as z223 } from "zod";
6311
- var DTOElementPropertyValue = z223.object({
6312
- id: z223.string(),
6313
- designSystemVersionId: z223.string(),
6314
- definitionId: z223.string(),
6315
- targetElementId: z223.string(),
6316
- value: z223.union([z223.string(), z223.number(), z223.boolean()]).optional(),
6317
- valuePreview: z223.string().optional()
6307
+ import { z as z224 } from "zod";
6308
+ var DTOElementPropertyValue = z224.object({
6309
+ id: z224.string(),
6310
+ designSystemVersionId: z224.string(),
6311
+ definitionId: z224.string(),
6312
+ targetElementId: z224.string(),
6313
+ value: z224.union([z224.string(), z224.number(), z224.boolean()]).optional(),
6314
+ valuePreview: z224.string().optional()
6318
6315
  });
6319
- var DTOElementPropertyValuesGetResponse = z223.object({
6320
- values: z223.array(DTOElementPropertyValue)
6316
+ var DTOElementPropertyValuesGetResponse = z224.object({
6317
+ values: z224.array(DTOElementPropertyValue)
6321
6318
  });
6322
6319
 
6323
6320
  // src/api/dto/elements/elements-action-v2.ts
6324
- import { z as z224 } from "zod";
6325
- var DTOElementActionOutput = z224.discriminatedUnion("type", [
6321
+ import { z as z225 } from "zod";
6322
+ var DTOElementActionOutput = z225.discriminatedUnion("type", [
6326
6323
  // Documentation pages
6327
6324
  DTODocumentationPageCreateActionOutputV2,
6328
6325
  DTODocumentationPageUpdateActionOutputV2,
@@ -6349,7 +6346,7 @@ var DTOElementActionOutput = z224.discriminatedUnion("type", [
6349
6346
  // Approvals
6350
6347
  DTODocumentationPageApprovalStateChangeActionOutput
6351
6348
  ]);
6352
- var DTOElementActionInput = z224.discriminatedUnion("type", [
6349
+ var DTOElementActionInput = z225.discriminatedUnion("type", [
6353
6350
  // Documentation pages
6354
6351
  DTODocumentationPageCreateActionInputV2,
6355
6352
  DTODocumentationPageUpdateActionInputV2,
@@ -6378,60 +6375,60 @@ var DTOElementActionInput = z224.discriminatedUnion("type", [
6378
6375
  ]);
6379
6376
 
6380
6377
  // src/api/dto/elements/get-elements-v2.ts
6381
- import { z as z225 } from "zod";
6382
- var DTOElementsGetTypeFilter = z225.enum(["FigmaNode"]);
6383
- var DTOElementsGetQuerySchema = z225.object({
6384
- types: z225.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
6378
+ import { z as z226 } from "zod";
6379
+ var DTOElementsGetTypeFilter = z226.enum(["FigmaNode"]);
6380
+ var DTOElementsGetQuerySchema = z226.object({
6381
+ types: z226.string().transform((val) => val.split(",").map((v) => DTOElementsGetTypeFilter.parse(v)))
6385
6382
  });
6386
- var DTOElementsGetOutput = z225.object({
6387
- figmaNodes: z225.array(DTOFigmaNode).optional()
6383
+ var DTOElementsGetOutput = z226.object({
6384
+ figmaNodes: z226.array(DTOFigmaNode).optional()
6388
6385
  });
6389
6386
 
6390
6387
  // src/api/dto/figma-components/assets/download.ts
6391
- import { z as z226 } from "zod";
6392
- var DTOAssetRenderConfiguration = z226.object({
6393
- prefix: z226.string().optional(),
6394
- suffix: z226.string().optional(),
6395
- scale: z226.enum(["x1", "x2", "x3", "x4"]),
6396
- format: z226.enum(["png", "pdf", "svg"])
6397
- });
6398
- var DTORenderedAssetFile = z226.object({
6399
- assetId: z226.string(),
6400
- fileName: z226.string(),
6401
- sourceUrl: z226.string(),
6388
+ import { z as z227 } from "zod";
6389
+ var DTOAssetRenderConfiguration = z227.object({
6390
+ prefix: z227.string().optional(),
6391
+ suffix: z227.string().optional(),
6392
+ scale: z227.enum(["x1", "x2", "x3", "x4"]),
6393
+ format: z227.enum(["png", "pdf", "svg"])
6394
+ });
6395
+ var DTORenderedAssetFile = z227.object({
6396
+ assetId: z227.string(),
6397
+ fileName: z227.string(),
6398
+ sourceUrl: z227.string(),
6402
6399
  settings: DTOAssetRenderConfiguration,
6403
- originalName: z226.string()
6400
+ originalName: z227.string()
6404
6401
  });
6405
- var DTODownloadAssetsRequest = z226.object({
6406
- persistentIds: z226.array(z226.string().uuid()).optional(),
6402
+ var DTODownloadAssetsRequest = z227.object({
6403
+ persistentIds: z227.array(z227.string().uuid()).optional(),
6407
6404
  settings: DTOAssetRenderConfiguration.array()
6408
6405
  });
6409
- var DTODownloadAssetsResponse = z226.object({
6406
+ var DTODownloadAssetsResponse = z227.object({
6410
6407
  items: DTORenderedAssetFile.array()
6411
6408
  });
6412
6409
 
6413
6410
  // src/api/dto/liveblocks/auth-response.ts
6414
- import { z as z227 } from "zod";
6415
- var DTOLiveblocksAuthResponse = z227.object({
6416
- token: z227.string()
6411
+ import { z as z228 } from "zod";
6412
+ var DTOLiveblocksAuthResponse = z228.object({
6413
+ token: z228.string()
6417
6414
  });
6418
6415
 
6419
6416
  // src/api/dto/users/authenticated-user.ts
6420
- import { z as z229 } from "zod";
6417
+ import { z as z230 } from "zod";
6421
6418
 
6422
6419
  // src/api/dto/users/user.ts
6423
- import { z as z228 } from "zod";
6424
- var DTOUserProfile = z228.object({
6425
- name: z228.string(),
6426
- nickname: z228.string().optional(),
6427
- avatar: z228.string().optional()
6428
- });
6429
- var DTOUser = z228.object({
6430
- id: z228.string(),
6431
- email: z228.string(),
6420
+ import { z as z229 } from "zod";
6421
+ var DTOUserProfile = z229.object({
6422
+ name: z229.string(),
6423
+ nickname: z229.string().optional(),
6424
+ avatar: z229.string().optional()
6425
+ });
6426
+ var DTOUser = z229.object({
6427
+ id: z229.string(),
6428
+ email: z229.string(),
6432
6429
  profile: DTOUserProfile
6433
6430
  });
6434
- var DTOUserGetResponse = z228.object({
6431
+ var DTOUserGetResponse = z229.object({
6435
6432
  user: DTOUser
6436
6433
  });
6437
6434
 
@@ -6439,34 +6436,34 @@ var DTOUserGetResponse = z228.object({
6439
6436
  var DTOUserOnboardingDepartment = UserOnboardingDepartment;
6440
6437
  var DTOUserOnboardingJobLevel = UserOnboardingJobLevel;
6441
6438
  var DTOUserSource = UserSource;
6442
- var DTOUserOnboarding = z229.object({
6443
- companyName: z229.string().optional(),
6444
- numberOfPeopleInOrg: z229.string().optional(),
6445
- numberOfPeopleInDesignTeam: z229.string().optional(),
6439
+ var DTOUserOnboarding = z230.object({
6440
+ companyName: z230.string().optional(),
6441
+ numberOfPeopleInOrg: z230.string().optional(),
6442
+ numberOfPeopleInDesignTeam: z230.string().optional(),
6446
6443
  department: DTOUserOnboardingDepartment.optional(),
6447
- jobTitle: z229.string().optional(),
6448
- phase: z229.string().optional(),
6444
+ jobTitle: z230.string().optional(),
6445
+ phase: z230.string().optional(),
6449
6446
  jobLevel: DTOUserOnboardingJobLevel.optional(),
6450
- designSystemName: z229.string().optional(),
6451
- defaultDestination: z229.string().optional(),
6452
- isPageDraftOnboardingFinished: z229.boolean().optional()
6447
+ designSystemName: z230.string().optional(),
6448
+ defaultDestination: z230.string().optional(),
6449
+ isPageDraftOnboardingFinished: z230.boolean().optional()
6453
6450
  });
6454
6451
  var DTOAuthenticatedUserProfile = DTOUserProfile.extend({
6455
6452
  onboarding: DTOUserOnboarding.optional()
6456
6453
  });
6457
6454
  var DTOAuthenticatedUser = DTOUser.extend({
6458
6455
  profile: DTOAuthenticatedUserProfile,
6459
- createdAt: z229.coerce.date(),
6460
- loggedOutAt: z229.coerce.date().optional(),
6456
+ createdAt: z230.coerce.date(),
6457
+ loggedOutAt: z230.coerce.date().optional(),
6461
6458
  source: DTOUserSource.optional()
6462
6459
  });
6463
- var DTOAuthenticatedUserResponse = z229.object({
6460
+ var DTOAuthenticatedUserResponse = z230.object({
6464
6461
  user: DTOAuthenticatedUser
6465
6462
  });
6466
6463
 
6467
6464
  // src/api/dto/users/update.ts
6468
- import { z as z230 } from "zod";
6469
- var DTOUserProfileUpdateResponse = z230.object({
6465
+ import { z as z231 } from "zod";
6466
+ var DTOUserProfileUpdateResponse = z231.object({
6470
6467
  user: User
6471
6468
  });
6472
6469
 
@@ -6489,7 +6486,7 @@ var DesignSystemMembersEndpoint = class {
6489
6486
  };
6490
6487
 
6491
6488
  // src/api/endpoints/design-systems.ts
6492
- import { z as z231 } from "zod";
6489
+ import { z as z232 } from "zod";
6493
6490
  var DesignSystemsEndpoint = class {
6494
6491
  constructor(requestExecutor) {
6495
6492
  this.requestExecutor = requestExecutor;
@@ -6503,10 +6500,10 @@ var DesignSystemsEndpoint = class {
6503
6500
  return this.requestExecutor.json(`/workspaces/${wsId}/design-systems`, DTODesignSystemsListResponse);
6504
6501
  }
6505
6502
  get(dsId) {
6506
- return this.requestExecutor.json(`/design-systems/${dsId}`, z231.any());
6503
+ return this.requestExecutor.json(`/design-systems/${dsId}`, z232.any());
6507
6504
  }
6508
6505
  delete(dsId) {
6509
- return this.requestExecutor.json(`/design-systems/${dsId}`, z231.any(), { method: "DELETE" });
6506
+ return this.requestExecutor.json(`/design-systems/${dsId}`, z232.any(), { method: "DELETE" });
6510
6507
  }
6511
6508
  update(dsId, body) {
6512
6509
  return this.requestExecutor.json(`/design-systems/${dsId}`, DTODesignSystemResponse, {
@@ -6551,7 +6548,7 @@ var WorkspaceInvitationsEndpoint = class {
6551
6548
  };
6552
6549
 
6553
6550
  // src/api/endpoints/workspace-members.ts
6554
- import { z as z232 } from "zod";
6551
+ import { z as z233 } from "zod";
6555
6552
  var WorkspaceMembersEndpoint = class {
6556
6553
  constructor(requestExecutor) {
6557
6554
  this.requestExecutor = requestExecutor;
@@ -6568,7 +6565,7 @@ var WorkspaceMembersEndpoint = class {
6568
6565
  });
6569
6566
  }
6570
6567
  invite(workspaceId, body) {
6571
- return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z232.any(), { method: "POST", body });
6568
+ return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z233.any(), { method: "POST", body });
6572
6569
  }
6573
6570
  delete(workspaceId, userId) {
6574
6571
  return this.requestExecutor.json(`/workspaces/${workspaceId}/members/${userId}`, DTOWorkspaceResponse, {
@@ -6578,7 +6575,7 @@ var WorkspaceMembersEndpoint = class {
6578
6575
  };
6579
6576
 
6580
6577
  // src/api/endpoints/workspaces.ts
6581
- import { z as z233 } from "zod";
6578
+ import { z as z234 } from "zod";
6582
6579
  var WorkspacesEndpoint = class {
6583
6580
  constructor(requestExecutor) {
6584
6581
  this.requestExecutor = requestExecutor;
@@ -6598,34 +6595,56 @@ var WorkspacesEndpoint = class {
6598
6595
  });
6599
6596
  }
6600
6597
  delete(workspaceId) {
6601
- return this.requestExecutor.json(`/workspaces/${workspaceId}`, z233.any(), { method: "DELETE" });
6598
+ return this.requestExecutor.json(`/workspaces/${workspaceId}`, z234.any(), { method: "DELETE" });
6602
6599
  }
6603
6600
  subscription(workspaceId) {
6604
- return this.requestExecutor.json(`/workspaces/${workspaceId}/subscription`, z233.any(), { method: "GET" });
6601
+ return this.requestExecutor.json(`/workspaces/${workspaceId}/subscription`, z234.any(), { method: "GET" });
6605
6602
  }
6606
6603
  };
6607
6604
 
6608
6605
  // src/api/transport/request-executor-error.ts
6609
6606
  var RequestExecutorError = class _RequestExecutorError extends Error {
6610
- constructor(type, message, cause) {
6607
+ constructor(type, message, errorCode, cause) {
6611
6608
  super(`${type}: ${message}`, { cause });
6612
6609
  __publicField(this, "type");
6610
+ __publicField(this, "errorCode");
6613
6611
  this.type = type;
6612
+ this.errorCode = errorCode;
6613
+ }
6614
+ static tryParseErrorCode(body) {
6615
+ try {
6616
+ const errorObj = JSON.parse(body);
6617
+ if (errorObj && typeof errorObj.errorCode === "string") {
6618
+ return errorObj.errorCode;
6619
+ }
6620
+ return null;
6621
+ } catch (e) {
6622
+ return null;
6623
+ }
6614
6624
  }
6615
6625
  static serverError(endpoint, status, bodyText) {
6616
- return new _RequestExecutorError("ServerError", `Endpoint ${endpoint} returned ${status}
6617
- ${bodyText}`);
6626
+ return new _RequestExecutorError(
6627
+ "ServerError",
6628
+ `Endpoint ${endpoint} returned ${status}
6629
+ ${bodyText}`,
6630
+ this.tryParseErrorCode(bodyText)
6631
+ );
6618
6632
  }
6619
6633
  static responseParsingError(endpoint, cause) {
6620
- return new _RequestExecutorError("ResponseParsingError", `Endpoint ${endpoint} returned incompatible JSON`, cause);
6634
+ return new _RequestExecutorError(
6635
+ "ResponseParsingError",
6636
+ `Endpoint ${endpoint} returned incompatible JSON`,
6637
+ void 0,
6638
+ cause
6639
+ );
6621
6640
  }
6622
6641
  };
6623
6642
 
6624
6643
  // src/api/transport/request-executor.ts
6625
6644
  import fetch from "node-fetch";
6626
- import { z as z234 } from "zod";
6627
- var ResponseWrapper = z234.object({
6628
- result: z234.record(z234.any())
6645
+ import { z as z235 } from "zod";
6646
+ var ResponseWrapper = z235.object({
6647
+ result: z235.record(z235.any())
6629
6648
  });
6630
6649
  var RequestExecutor = class {
6631
6650
  constructor(testServerConfig) {
@@ -6747,7 +6766,7 @@ function generateHash(input, debug = false) {
6747
6766
  }
6748
6767
 
6749
6768
  // src/yjs/design-system-content/documentation-hierarchy.ts
6750
- import { z as z235 } from "zod";
6769
+ import { z as z236 } from "zod";
6751
6770
 
6752
6771
  // src/yjs/version-room/base.ts
6753
6772
  var VersionRoomBaseYDoc = class {
@@ -7276,24 +7295,24 @@ var FrontendVersionRoomYDoc = class {
7276
7295
  };
7277
7296
 
7278
7297
  // src/yjs/design-system-content/documentation-hierarchy.ts
7279
- var DocumentationHierarchySettings = z235.object({
7280
- routingVersion: z235.string(),
7281
- isDraftFeatureAdopted: z235.boolean(),
7282
- isApprovalFeatureEnabled: z235.boolean(),
7283
- approvalRequiredForPublishing: z235.boolean()
7298
+ var DocumentationHierarchySettings = z236.object({
7299
+ routingVersion: z236.string(),
7300
+ isDraftFeatureAdopted: z236.boolean(),
7301
+ isApprovalFeatureEnabled: z236.boolean(),
7302
+ approvalRequiredForPublishing: z236.boolean()
7284
7303
  });
7285
7304
  function yjsToDocumentationHierarchy(doc) {
7286
7305
  return new FrontendVersionRoomYDoc(doc).getDocumentationHierarchy();
7287
7306
  }
7288
7307
 
7289
7308
  // src/yjs/design-system-content/item-configuration.ts
7290
- import { z as z236 } from "zod";
7291
- var DTODocumentationPageRoomHeaderData = z236.object({
7292
- title: z236.string(),
7309
+ import { z as z237 } from "zod";
7310
+ var DTODocumentationPageRoomHeaderData = z237.object({
7311
+ title: z237.string(),
7293
7312
  configuration: DTODocumentationItemConfigurationV2
7294
7313
  });
7295
- var DTODocumentationPageRoomHeaderDataUpdate = z236.object({
7296
- title: z236.string().optional(),
7314
+ var DTODocumentationPageRoomHeaderDataUpdate = z237.object({
7315
+ title: z237.string().optional(),
7297
7316
  configuration: DTODocumentationItemConfigurationV2.omit({ header: true }).extend({ header: DocumentationItemHeaderV2.partial() }).optional()
7298
7317
  });
7299
7318
  function itemConfigurationToYjs(yDoc, item) {
@@ -7344,7 +7363,7 @@ function yjsToItemConfiguration(yDoc) {
7344
7363
  header: rawHeader
7345
7364
  };
7346
7365
  return {
7347
- title: z236.string().parse(title),
7366
+ title: z237.string().parse(title),
7348
7367
  configuration: DTODocumentationItemConfigurationV2.parse(rawConfig)
7349
7368
  };
7350
7369
  }
@@ -7354,9 +7373,9 @@ var PageBlockEditorModel = PageBlockEditorModelV2;
7354
7373
  var PageSectionEditorModel = PageSectionEditorModelV2;
7355
7374
 
7356
7375
  // src/yjs/docs-editor/model/page.ts
7357
- import { z as z237 } from "zod";
7358
- var DocumentationPageEditorModel = z237.object({
7359
- blocks: z237.array(DocumentationPageContentItem)
7376
+ import { z as z238 } from "zod";
7377
+ var DocumentationPageEditorModel = z238.object({
7378
+ blocks: z238.array(DocumentationPageContentItem)
7360
7379
  });
7361
7380
 
7362
7381
  // src/yjs/docs-editor/prosemirror/inner-editor-schema.ts
@@ -10707,7 +10726,7 @@ var blocks = [
10707
10726
 
10708
10727
  // src/yjs/docs-editor/prosemirror-to-blocks.ts
10709
10728
  import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
10710
- import { z as z238 } from "zod";
10729
+ import { z as z239 } from "zod";
10711
10730
  function yDocToPage(yDoc, definitions) {
10712
10731
  return yXmlFragmentToPage(yDoc.getXmlFragment("default"), definitions);
10713
10732
  }
@@ -10787,7 +10806,7 @@ function prosemirrorNodeToSectionItem(prosemirrorNode, definitionsMap) {
10787
10806
  return null;
10788
10807
  return {
10789
10808
  id,
10790
- title: getProsemirrorAttribute(prosemirrorNode, "title", z238.string()) ?? "",
10809
+ title: getProsemirrorAttribute(prosemirrorNode, "title", z239.string()) ?? "",
10791
10810
  columns: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItemColumn").map((c) => prosemirrorNodeToSectionColumns(c, definitionsMap)).filter(nonNullFilter)
10792
10811
  };
10793
10812
  }
@@ -10822,7 +10841,7 @@ function internalProsemirrorNodesToBlocks(prosemirrorNodes, definitionsMap, dept
10822
10841
  });
10823
10842
  }
10824
10843
  function internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap, depth) {
10825
- const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z238.string());
10844
+ const definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z239.string());
10826
10845
  if (!definitionId) {
10827
10846
  console.warn(`definitionId on ${prosemirrorNode.type} is required to be interpreted as a block, skipping node`);
10828
10847
  return [];
@@ -10864,7 +10883,7 @@ function parseAsRichText(prosemirrorNode, definition, property) {
10864
10883
  if (!id)
10865
10884
  return null;
10866
10885
  const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
10867
- const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z238.string().optional()));
10886
+ const calloutType = parseCalloutType(getProsemirrorAttribute(prosemirrorNode, "type", z239.string().optional()));
10868
10887
  return {
10869
10888
  id,
10870
10889
  type: "Block",
@@ -10992,10 +11011,10 @@ function parseRichTextAttribute(mark) {
10992
11011
  return null;
10993
11012
  }
10994
11013
  function parseProsemirrorLink(mark) {
10995
- const href = getProsemirrorAttribute(mark, "href", z238.string().optional());
11014
+ const href = getProsemirrorAttribute(mark, "href", z239.string().optional());
10996
11015
  if (!href)
10997
11016
  return null;
10998
- const target = getProsemirrorAttribute(mark, "target", z238.string().optional());
11017
+ const target = getProsemirrorAttribute(mark, "target", z239.string().optional());
10999
11018
  const openInNewTab = target === "_blank";
11000
11019
  if (href.startsWith("@")) {
11001
11020
  return {
@@ -11014,10 +11033,10 @@ function parseProsemirrorLink(mark) {
11014
11033
  }
11015
11034
  }
11016
11035
  function parseProsemirrorCommentHighlight(mark) {
11017
- const highlightId = getProsemirrorAttribute(mark, "highlightId", z238.string().optional());
11036
+ const highlightId = getProsemirrorAttribute(mark, "highlightId", z239.string().optional());
11018
11037
  if (!highlightId)
11019
11038
  return null;
11020
- const isResolved = getProsemirrorAttribute(mark, "resolved", z238.boolean().optional()) ?? false;
11039
+ const isResolved = getProsemirrorAttribute(mark, "resolved", z239.boolean().optional()) ?? false;
11021
11040
  return {
11022
11041
  type: "Comment",
11023
11042
  commentHighlightId: highlightId,
@@ -11029,7 +11048,7 @@ function parseAsTable(prosemirrorNode, definition, property) {
11029
11048
  if (!id)
11030
11049
  return null;
11031
11050
  const variantId = getProsemirrorBlockVariantId(prosemirrorNode);
11032
- const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z238.boolean().optional()) !== false;
11051
+ const hasBorder = getProsemirrorAttribute(prosemirrorNode, "hasBorder", z239.boolean().optional()) !== false;
11033
11052
  const tableChild = prosemirrorNode.content?.find((c) => c.type === "table");
11034
11053
  if (!tableChild) {
11035
11054
  return emptyTable(id, variantId, 0);
@@ -11076,9 +11095,9 @@ function parseAsTableCell(prosemirrorNode) {
11076
11095
  const id = getProsemirrorBlockId(prosemirrorNode);
11077
11096
  if (!id)
11078
11097
  return null;
11079
- const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z238.string().optional());
11098
+ const textAlign = getProsemirrorAttribute(prosemirrorNode, "textAlign", z239.string().optional());
11080
11099
  let columnWidth;
11081
- const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z238.array(z238.number()).nullish());
11100
+ const columnWidthArray = getProsemirrorAttribute(prosemirrorNode, "colwidth", z239.array(z239.number()).nullish());
11082
11101
  if (columnWidthArray) {
11083
11102
  columnWidth = roundDimension(columnWidthArray[0]);
11084
11103
  }
@@ -11116,7 +11135,7 @@ function parseAsTableNode(prosemirrorNode) {
11116
11135
  value: parseRichText(prosemirrorNode.content ?? [])
11117
11136
  };
11118
11137
  case "image":
11119
- const items = getProsemirrorAttribute(prosemirrorNode, "items", z238.string());
11138
+ const items = getProsemirrorAttribute(prosemirrorNode, "items", z239.string());
11120
11139
  if (!items)
11121
11140
  return null;
11122
11141
  const parsedItems = PageBlockItemV2.array().safeParse(JSON.parse(items));
@@ -11236,7 +11255,7 @@ function definitionExpectsPlaceholderItem(definition) {
11236
11255
  );
11237
11256
  }
11238
11257
  function parseBlockItems(prosemirrorNode, definition) {
11239
- const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z238.string());
11258
+ const itemsString = getProsemirrorAttribute(prosemirrorNode, "items", z239.string());
11240
11259
  if (!itemsString)
11241
11260
  return null;
11242
11261
  const itemsJson = JSON.parse(itemsString);
@@ -11248,18 +11267,18 @@ function parseBlockItems(prosemirrorNode, definition) {
11248
11267
  }
11249
11268
  function parseAppearance(prosemirrorNode) {
11250
11269
  let appearance = {};
11251
- const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z238.string().optional());
11270
+ const rawAppearanceString = getProsemirrorAttribute(prosemirrorNode, "appearance", z239.string().optional());
11252
11271
  if (rawAppearanceString) {
11253
11272
  const parsedAppearance = PageBlockAppearanceV2.safeParse(JSON.parse(rawAppearanceString));
11254
11273
  if (parsedAppearance.success) {
11255
11274
  appearance = parsedAppearance.data;
11256
11275
  }
11257
11276
  }
11258
- const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z238.number().optional());
11277
+ const columns = getProsemirrorAttribute(prosemirrorNode, "columns", z239.number().optional());
11259
11278
  if (columns) {
11260
11279
  appearance.numberOfColumns = columns;
11261
11280
  }
11262
- const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z238.string().optional());
11281
+ const backgroundColor = getProsemirrorAttribute(prosemirrorNode, "backgroundColor", z239.string().optional());
11263
11282
  if (backgroundColor) {
11264
11283
  const parsedColor = PageBlockColorV2.safeParse(JSON.parse(backgroundColor));
11265
11284
  if (parsedColor.success) {
@@ -11354,13 +11373,13 @@ function valueSchemaForPropertyType(type) {
11354
11373
  }
11355
11374
  }
11356
11375
  function getProsemirrorBlockId(prosemirrorNode) {
11357
- const id = getProsemirrorAttribute(prosemirrorNode, "id", z238.string());
11376
+ const id = getProsemirrorAttribute(prosemirrorNode, "id", z239.string());
11358
11377
  if (!id)
11359
11378
  console.warn(`Prosemirror attribute "id" on ${prosemirrorNode.type} is required`);
11360
11379
  return id;
11361
11380
  }
11362
11381
  function getProsemirrorBlockVariantId(prosemirrorNode) {
11363
- return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z238.string()));
11382
+ return getProsemirrorAttribute(prosemirrorNode, "variantId", nullishToOptional(z239.string()));
11364
11383
  }
11365
11384
  function getProsemirrorAttribute(prosemirrorNode, attributeName, validationSchema) {
11366
11385
  const parsedAttr = validationSchema.safeParse(prosemirrorNode.attrs?.[attributeName]);