@opusdns/api 0.265.0 → 0.267.0

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.
package/package.json CHANGED
@@ -3,7 +3,7 @@
3
3
  "@opusdns/api-spec-ts-generator": "^0.19.0"
4
4
  },
5
5
  "name": "@opusdns/api",
6
- "version": "0.265.0",
6
+ "version": "0.267.0",
7
7
  "description": "TypeScript types for the OpusDNS OpenAPI specification",
8
8
  "main": "./src/index.ts",
9
9
  "module": "./src/index.ts",
@@ -21,7 +21,7 @@
21
21
  * ```
22
22
  */
23
23
 
24
- import { AllocationMethodType, AttributeType, BatchSortField, BatchStatus, BillingTransactionAction, BillingTransactionProductType, BillingTransactionSortField, BillingTransactionStatus, ComplianceStatus, ConditionOperator, ContactAttributeSetSortField, ContactSortField, Currency, DeletePolicyType, DnsChangeAction, DnsProtectedReason, DnsRrsetType, DnssecAlgorithm, DnssecDigestType, DnssecModeType, DnssecRecordType, DnssecStatus, DomainAttributeKey, DomainAvailabilityStatus, DomainClientStatus, DomainContactType, DomainForwardSortField, DomainForwardZoneSortField, DomainIncludeField, DomainSortField, DomainStatus, EmailForwardLogSortField, EmailForwardLogStatus, EmailForwardSortField, EmailForwardZoneSortField, EmailVerificationStatus, EventObjectType, EventSortField, EventSubtype, EventType, ExecutingEntity, HTTPMethod, HostStatus, HttpProtocol, InvoiceResponsePaymentStatus, InvoiceResponseStatus, InvoiceResponseType, JobStatus, LaunchPhaseType, LegalRequirementOperationType, LegalRequirementType, LocalPresenceRequirementType, MetricsGrouping, ObjectEventType, ObjectLogSortField, OrganizationSortField, OrganizationStatus, ParkingSortField, PatchOp, PeriodUnit, Permission, PostTransferRequirements, PostalAddressType, PremiumAffectsType, PremiumSourceType, Protocol, RedirectCode, RegistrantChangeType, RegistryHandleAttributeType, Relation, RenewalMode, ReportStatus, ReportTriggerType, ReportType, RequestHistorySortField, ReservedSourceType, SortOrder, SyncOperationType, TLDType, TagColor, TagFilterMode, TagSortField, TagType, TimeRange, TransferAckType, UserSortField, UserStatus, VerificationType, ZoneSortField } from './schemas';
24
+ import { AllocationMethodType, AttributeType, BatchSortField, BatchStatus, BillingTransactionAction, BillingTransactionProductType, BillingTransactionSortField, BillingTransactionStatus, ComplianceStatus, ConditionOperator, ContactAttributeSetSortField, ContactSortField, Currency, DeletePolicyType, DnsChangeAction, DnsProtectedReason, DnsRrsetType, DnssecAlgorithm, DnssecDigestType, DnssecModeType, DnssecRecordType, DnssecStatus, DomainAttributeKey, DomainAvailabilityStatus, DomainClientStatus, DomainContactType, DomainForwardSortField, DomainForwardZoneSortField, DomainIncludeField, DomainSortField, DomainStatus, EmailForwardLogSortField, EmailForwardLogStatus, EmailForwardSortField, EmailForwardZoneSortField, EmailVerificationStatus, EventObjectType, EventSortField, EventSubtype, EventType, ExecutingEntity, HTTPMethod, HostStatus, HttpProtocol, InvoiceResponsePaymentStatus, InvoiceResponseStatus, InvoiceResponseType, JobStatus, LaunchPhaseType, LegalRequirementOperationType, LegalRequirementType, LocalPresenceRequirementType, MetricsGrouping, ObjectEventType, ObjectLogSortField, OrganizationSortField, OrganizationStatus, ParkingSortField, PatchOp, PeriodUnit, Permission, PostTransferRequirements, PostalAddressType, PremiumAffectsType, PremiumSourceType, Protocol, RedirectCode, RegistrantChangeType, RegistryHandleAttributeType, Relation, RenewalMode, ReportStatus, ReportTriggerType, ReportType, RequestHistorySortField, ReservedSourceType, SortOrder, SyncOperationType, TLDType, TagColor, TagFilterMode, TagSortField, TagType, TimeRange, TransferAckType, UserSortField, UserStatus, VerificationType, ZoneIncludeField, ZoneSortField } from './schemas';
25
25
 
26
26
  /**
27
27
  * AllocationMethodType. Auto-generated enum for AllocationMethodType
@@ -4967,6 +4967,54 @@ export const VERIFICATION_TYPE_VALUES = [
4967
4967
  'email'
4968
4968
  ] as const satisfies [string, ...string[]] | VerificationType[];
4969
4969
 
4970
+ /**
4971
+ * ZoneIncludeField. Auto-generated enum for ZoneIncludeField
4972
+ *
4973
+ * @remarks
4974
+ * This constant provides both object and array forms for the ZoneIncludeField enum.
4975
+ * The object form allows key-value access, while the array form enables iteration and validation.
4976
+ *
4977
+ * @example
4978
+ * ```typescript
4979
+ * // Using the object form for key-value access
4980
+ * const status = ZONE_INCLUDE_FIELD.SUCCESS;
4981
+ *
4982
+ * // Using the array form for iteration
4983
+ * const allStatuses = ZONE_INCLUDE_FIELD_VALUES;
4984
+ * console.log(`Available statuses: ${allStatuses.join(', ')}`);
4985
+ * ```
4986
+ *
4987
+ * @see {@link ZoneIncludeField} - The TypeScript type definition
4988
+ */
4989
+ export const ZONE_INCLUDE_FIELD = {
4990
+ TAGS: "tags",
4991
+ } as const satisfies Record<string, ZoneIncludeField>;
4992
+
4993
+ /**
4994
+ * Array of all ZoneIncludeField enum values
4995
+ *
4996
+ * @remarks
4997
+ * This constant provides a array containing all valid ZoneIncludeField enum values.
4998
+ * Useful for iteration, validation, and generating dynamic UI components.
4999
+ *
5000
+ * @example
5001
+ * ```typescript
5002
+ * // Iterating through all values
5003
+ * for (const value of ZONE_INCLUDE_FIELD_VALUES) {
5004
+ * console.log(`Processing: ${value}`);
5005
+ * }
5006
+ *
5007
+ * // Validation
5008
+ * const isValid = ZONE_INCLUDE_FIELD_VALUES.includes(someValue);
5009
+ * ```
5010
+ *
5011
+ * @see {@link ZoneIncludeField} - The TypeScript type definition
5012
+ * @see {@link ZONE_INCLUDE_FIELD} - The object form of this enum
5013
+ */
5014
+ export const ZONE_INCLUDE_FIELD_VALUES = [
5015
+ 'tags'
5016
+ ] as const satisfies [string, ...string[]] | ZoneIncludeField[];
5017
+
4970
5018
  /**
4971
5019
  * ZoneSortField. Auto-generated enum for ZoneSortField
4972
5020
  *
@@ -61,7 +61,6 @@ import { ContactVerification } from './schemas';
61
61
  import { ContactsBase } from './schemas';
62
62
  import { CreateJobBatch } from './schemas';
63
63
  import { CreateReportReq } from './schemas';
64
- import { DeletedEvent } from './schemas';
65
64
  import { DnsChange } from './schemas';
66
65
  import { DnsChanges } from './schemas';
67
66
  import { DnsConfigurationBase } from './schemas';
@@ -152,7 +151,6 @@ import { DomainStatus2 } from './schemas';
152
151
  import { DomainStatusesBase } from './schemas';
153
152
  import { DomainSummaryData } from './schemas';
154
153
  import { DomainSummary } from './schemas';
155
- import { DomainTagEnriched } from './schemas';
156
154
  import { DomainTransferBulkCommand } from './schemas';
157
155
  import { DomainTransferBulkInstance } from './schemas';
158
156
  import { DomainTransferBulkPayload } from './schemas';
@@ -271,7 +269,6 @@ import { RdapBase } from './schemas';
271
269
  import { ReferrerStatsBucket } from './schemas';
272
270
  import { RegistryLockBase } from './schemas';
273
271
  import { RelationSet } from './schemas';
274
- import { RenewalEvent } from './schemas';
275
272
  import { RequestHistory } from './schemas';
276
273
  import { ReservedDomainsBase } from './schemas';
277
274
  import { RgpOperations } from './schemas';
@@ -280,6 +277,7 @@ import { SpiceDbRelationshipUpdate } from './schemas';
280
277
  import { StatusChanges } from './schemas';
281
278
  import { StatusCodeStatsBucket } from './schemas';
282
279
  import { TagCreate } from './schemas';
280
+ import { TagEnriched } from './schemas';
283
281
  import { Tag } from './schemas';
284
282
  import { TagUpdate } from './schemas';
285
283
  import { TimeSeriesBucket } from './schemas';
@@ -287,7 +285,6 @@ import { TldBase } from './schemas';
287
285
  import { TldResponseShort } from './schemas';
288
286
  import { TldSpecification } from './schemas';
289
287
  import { TrademarkClaimsBase } from './schemas';
290
- import { TransferEvent } from './schemas';
291
288
  import { TransferLockPolicyBase } from './schemas';
292
289
  import { TransferPoliciesBase } from './schemas';
293
290
  import { User } from './schemas';
@@ -6460,55 +6457,6 @@ export const KEYS_CREATE_REPORT_REQ = [
6460
6457
  KEY_CREATE_REPORT_REQ_REPORT_TYPE,
6461
6458
  ] as const satisfies (keyof CreateReportReq)[];
6462
6459
 
6463
- /**
6464
- * date property
6465
- *
6466
- *
6467
- *
6468
- *
6469
- * @remarks
6470
- * This key constant provides type-safe access to the `date` property of DeletedEvent objects.
6471
- * Use this constant when you need to access properties dynamically or ensure type safety.
6472
- *
6473
- * @example
6474
- * ```typescript
6475
- * // Direct property access
6476
- * const value = deletedevent[KEY_DELETED_EVENT_DATE];
6477
- *
6478
- * // Dynamic property access
6479
- * const propertyName = KEY_DELETED_EVENT_DATE;
6480
- * const value = deletedevent[propertyName];
6481
- * ```
6482
- *
6483
- * @see {@link DeletedEvent} - The TypeScript type definition
6484
- * @see {@link KEYS_DELETED_EVENT} - Array of all keys for this type
6485
- */
6486
- export const KEY_DELETED_EVENT_DATE: keyof DeletedEvent = 'date';
6487
-
6488
- /**
6489
- * Array of all DeletedEvent property keys
6490
- *
6491
- * @remarks
6492
- * This constant provides a readonly array containing all valid property keys for DeletedEvent objects.
6493
- * Useful for iteration, validation, and generating dynamic UI components.
6494
- *
6495
- * @example
6496
- * ```typescript
6497
- * // Iterating through all keys
6498
- * for (const key of KEYS_DELETED_EVENT) {
6499
- * console.log(`Property: ${key}, Value: ${deletedevent[key]}`);
6500
- * }
6501
- *
6502
- * // Validation
6503
- * const isValidKey = KEYS_DELETED_EVENT.includes(someKey);
6504
- * ```
6505
- *
6506
- * @see {@link DeletedEvent} - The TypeScript type definition
6507
- */
6508
- export const KEYS_DELETED_EVENT = [
6509
- KEY_DELETED_EVENT_DATE,
6510
- ] as const satisfies (keyof DeletedEvent)[];
6511
-
6512
6460
  /**
6513
6461
  * action property
6514
6462
  *
@@ -9516,6 +9464,32 @@ export const KEYS_DNS_ZONE_RECORDS_PATCH_OPS = [
9516
9464
  * @see {@link KEYS_DNS_ZONE} - Array of all keys for this type
9517
9465
  */
9518
9466
  export const KEY_DNS_ZONE_CREATED_ON: keyof DnsZone = 'created_on';
9467
+ /**
9468
+ * Dns Zone Id
9469
+ *
9470
+ * The unique identifier of the zone
9471
+ *
9472
+ * @type {string}
9473
+ *
9474
+ *
9475
+ * @remarks
9476
+ * This key constant provides type-safe access to the `dns_zone_id` property of DnsZone objects.
9477
+ * Use this constant when you need to access properties dynamically or ensure type safety.
9478
+ *
9479
+ * @example
9480
+ * ```typescript
9481
+ * // Direct property access
9482
+ * const value = dnszone[KEY_DNS_ZONE_DNS_ZONE_ID];
9483
+ *
9484
+ * // Dynamic property access
9485
+ * const propertyName = KEY_DNS_ZONE_DNS_ZONE_ID;
9486
+ * const value = dnszone[propertyName];
9487
+ * ```
9488
+ *
9489
+ * @see {@link DnsZone} - The TypeScript type definition
9490
+ * @see {@link KEYS_DNS_ZONE} - Array of all keys for this type
9491
+ */
9492
+ export const KEY_DNS_ZONE_DNS_ZONE_ID: keyof DnsZone = 'dns_zone_id';
9519
9493
  /**
9520
9494
  * dnssec_status property
9521
9495
  *
@@ -9614,6 +9588,31 @@ export const KEY_DNS_ZONE_NAME: keyof DnsZone = 'name';
9614
9588
  * @see {@link KEYS_DNS_ZONE} - Array of all keys for this type
9615
9589
  */
9616
9590
  export const KEY_DNS_ZONE_RRSETS: keyof DnsZone = 'rrsets';
9591
+ /**
9592
+ * Tags
9593
+ *
9594
+ * Tags assigned to this zone. Only included when ?include=tags is specified.
9595
+ *
9596
+ *
9597
+ *
9598
+ * @remarks
9599
+ * This key constant provides type-safe access to the `tags` property of DnsZone objects.
9600
+ * Use this constant when you need to access properties dynamically or ensure type safety.
9601
+ *
9602
+ * @example
9603
+ * ```typescript
9604
+ * // Direct property access
9605
+ * const value = dnszone[KEY_DNS_ZONE_TAGS];
9606
+ *
9607
+ * // Dynamic property access
9608
+ * const propertyName = KEY_DNS_ZONE_TAGS;
9609
+ * const value = dnszone[propertyName];
9610
+ * ```
9611
+ *
9612
+ * @see {@link DnsZone} - The TypeScript type definition
9613
+ * @see {@link KEYS_DNS_ZONE} - Array of all keys for this type
9614
+ */
9615
+ export const KEY_DNS_ZONE_TAGS: keyof DnsZone = 'tags';
9617
9616
  /**
9618
9617
  * Updated On
9619
9618
  *
@@ -9663,10 +9662,12 @@ export const KEY_DNS_ZONE_UPDATED_ON: keyof DnsZone = 'updated_on';
9663
9662
  */
9664
9663
  export const KEYS_DNS_ZONE = [
9665
9664
  KEY_DNS_ZONE_CREATED_ON,
9665
+ KEY_DNS_ZONE_DNS_ZONE_ID,
9666
9666
  KEY_DNS_ZONE_DNSSEC_STATUS,
9667
9667
  KEY_DNS_ZONE_DOMAIN_PARTS,
9668
9668
  KEY_DNS_ZONE_NAME,
9669
9669
  KEY_DNS_ZONE_RRSETS,
9670
+ KEY_DNS_ZONE_TAGS,
9670
9671
  KEY_DNS_ZONE_UPDATED_ON,
9671
9672
  ] as const satisfies (keyof DnsZone)[];
9672
9673
 
@@ -16726,110 +16727,6 @@ export const KEYS_DOMAIN_SUMMARY = [
16726
16727
  KEY_DOMAIN_SUMMARY_ORGANIZATION_ID,
16727
16728
  ] as const satisfies (keyof DomainSummary)[];
16728
16729
 
16729
- /**
16730
- * color property
16731
- *
16732
- * The color of the tag
16733
- *
16734
- *
16735
- *
16736
- * @remarks
16737
- * This key constant provides type-safe access to the `color` property of DomainTagEnriched objects.
16738
- * Use this constant when you need to access properties dynamically or ensure type safety.
16739
- *
16740
- * @example
16741
- * ```typescript
16742
- * // Direct property access
16743
- * const value = domaintagenriched[KEY_DOMAIN_TAG_ENRICHED_COLOR];
16744
- *
16745
- * // Dynamic property access
16746
- * const propertyName = KEY_DOMAIN_TAG_ENRICHED_COLOR;
16747
- * const value = domaintagenriched[propertyName];
16748
- * ```
16749
- *
16750
- * @see {@link DomainTagEnriched} - The TypeScript type definition
16751
- * @see {@link KEYS_DOMAIN_TAG_ENRICHED} - Array of all keys for this type
16752
- */
16753
- export const KEY_DOMAIN_TAG_ENRICHED_COLOR: keyof DomainTagEnriched = 'color';
16754
- /**
16755
- * Label
16756
- *
16757
- * The label of the tag
16758
- *
16759
- * @type {string}
16760
- *
16761
- *
16762
- * @remarks
16763
- * This key constant provides type-safe access to the `label` property of DomainTagEnriched objects.
16764
- * Use this constant when you need to access properties dynamically or ensure type safety.
16765
- *
16766
- * @example
16767
- * ```typescript
16768
- * // Direct property access
16769
- * const value = domaintagenriched[KEY_DOMAIN_TAG_ENRICHED_LABEL];
16770
- *
16771
- * // Dynamic property access
16772
- * const propertyName = KEY_DOMAIN_TAG_ENRICHED_LABEL;
16773
- * const value = domaintagenriched[propertyName];
16774
- * ```
16775
- *
16776
- * @see {@link DomainTagEnriched} - The TypeScript type definition
16777
- * @see {@link KEYS_DOMAIN_TAG_ENRICHED} - Array of all keys for this type
16778
- */
16779
- export const KEY_DOMAIN_TAG_ENRICHED_LABEL: keyof DomainTagEnriched = 'label';
16780
- /**
16781
- * Tag Id
16782
- *
16783
- * The unique identifier of the tag
16784
- *
16785
- * @type {string}
16786
- *
16787
- *
16788
- * @remarks
16789
- * This key constant provides type-safe access to the `tag_id` property of DomainTagEnriched objects.
16790
- * Use this constant when you need to access properties dynamically or ensure type safety.
16791
- *
16792
- * @example
16793
- * ```typescript
16794
- * // Direct property access
16795
- * const value = domaintagenriched[KEY_DOMAIN_TAG_ENRICHED_TAG_ID];
16796
- *
16797
- * // Dynamic property access
16798
- * const propertyName = KEY_DOMAIN_TAG_ENRICHED_TAG_ID;
16799
- * const value = domaintagenriched[propertyName];
16800
- * ```
16801
- *
16802
- * @see {@link DomainTagEnriched} - The TypeScript type definition
16803
- * @see {@link KEYS_DOMAIN_TAG_ENRICHED} - Array of all keys for this type
16804
- */
16805
- export const KEY_DOMAIN_TAG_ENRICHED_TAG_ID: keyof DomainTagEnriched = 'tag_id';
16806
-
16807
- /**
16808
- * Array of all DomainTagEnriched property keys
16809
- *
16810
- * @remarks
16811
- * This constant provides a readonly array containing all valid property keys for DomainTagEnriched objects.
16812
- * Useful for iteration, validation, and generating dynamic UI components.
16813
- *
16814
- * @example
16815
- * ```typescript
16816
- * // Iterating through all keys
16817
- * for (const key of KEYS_DOMAIN_TAG_ENRICHED) {
16818
- * console.log(`Property: ${key}, Value: ${domaintagenriched[key]}`);
16819
- * }
16820
- *
16821
- * // Validation
16822
- * const isValidKey = KEYS_DOMAIN_TAG_ENRICHED.includes(someKey);
16823
- * ```
16824
- *
16825
- * @see {@link DomainTagEnriched} - The TypeScript type definition
16826
- */
16827
- export const KEYS_DOMAIN_TAG_ENRICHED = [
16828
- KEY_DOMAIN_TAG_ENRICHED_COLOR,
16829
- KEY_DOMAIN_TAG_ENRICHED_LABEL,
16830
- KEY_DOMAIN_TAG_ENRICHED_TAG_ID,
16831
- ] as const satisfies (keyof DomainTagEnriched)[];
16832
-
16833
16730
  /**
16834
16731
  * Command
16835
16732
  *
@@ -33950,57 +33847,6 @@ export const KEYS_RELATION_SET = [
33950
33847
  KEY_RELATION_SET_RELATIONS,
33951
33848
  ] as const satisfies (keyof RelationSet)[];
33952
33849
 
33953
- /**
33954
- * Registration Expiration Date
33955
- *
33956
- * The new expiration date/time after the domain has been renewed
33957
- *
33958
- * @type {string}
33959
- *
33960
- *
33961
- * @remarks
33962
- * This key constant provides type-safe access to the `registration_expiration_date` property of RenewalEvent objects.
33963
- * Use this constant when you need to access properties dynamically or ensure type safety.
33964
- *
33965
- * @example
33966
- * ```typescript
33967
- * // Direct property access
33968
- * const value = renewalevent[KEY_RENEWAL_EVENT_REGISTRATION_EXPIRATION_DATE];
33969
- *
33970
- * // Dynamic property access
33971
- * const propertyName = KEY_RENEWAL_EVENT_REGISTRATION_EXPIRATION_DATE;
33972
- * const value = renewalevent[propertyName];
33973
- * ```
33974
- *
33975
- * @see {@link RenewalEvent} - The TypeScript type definition
33976
- * @see {@link KEYS_RENEWAL_EVENT} - Array of all keys for this type
33977
- */
33978
- export const KEY_RENEWAL_EVENT_REGISTRATION_EXPIRATION_DATE: keyof RenewalEvent = 'registration_expiration_date';
33979
-
33980
- /**
33981
- * Array of all RenewalEvent property keys
33982
- *
33983
- * @remarks
33984
- * This constant provides a readonly array containing all valid property keys for RenewalEvent objects.
33985
- * Useful for iteration, validation, and generating dynamic UI components.
33986
- *
33987
- * @example
33988
- * ```typescript
33989
- * // Iterating through all keys
33990
- * for (const key of KEYS_RENEWAL_EVENT) {
33991
- * console.log(`Property: ${key}, Value: ${renewalevent[key]}`);
33992
- * }
33993
- *
33994
- * // Validation
33995
- * const isValidKey = KEYS_RENEWAL_EVENT.includes(someKey);
33996
- * ```
33997
- *
33998
- * @see {@link RenewalEvent} - The TypeScript type definition
33999
- */
34000
- export const KEYS_RENEWAL_EVENT = [
34001
- KEY_RENEWAL_EVENT_REGISTRATION_EXPIRATION_DATE,
34002
- ] as const satisfies (keyof RenewalEvent)[];
34003
-
34004
33850
  /**
34005
33851
  * Client Ip
34006
33852
  *
@@ -34960,6 +34806,110 @@ export const KEYS_TAG_CREATE = [
34960
34806
  KEY_TAG_CREATE_TYPE,
34961
34807
  ] as const satisfies (keyof TagCreate)[];
34962
34808
 
34809
+ /**
34810
+ * color property
34811
+ *
34812
+ * The color of the tag
34813
+ *
34814
+ *
34815
+ *
34816
+ * @remarks
34817
+ * This key constant provides type-safe access to the `color` property of TagEnriched objects.
34818
+ * Use this constant when you need to access properties dynamically or ensure type safety.
34819
+ *
34820
+ * @example
34821
+ * ```typescript
34822
+ * // Direct property access
34823
+ * const value = tagenriched[KEY_TAG_ENRICHED_COLOR];
34824
+ *
34825
+ * // Dynamic property access
34826
+ * const propertyName = KEY_TAG_ENRICHED_COLOR;
34827
+ * const value = tagenriched[propertyName];
34828
+ * ```
34829
+ *
34830
+ * @see {@link TagEnriched} - The TypeScript type definition
34831
+ * @see {@link KEYS_TAG_ENRICHED} - Array of all keys for this type
34832
+ */
34833
+ export const KEY_TAG_ENRICHED_COLOR: keyof TagEnriched = 'color';
34834
+ /**
34835
+ * Label
34836
+ *
34837
+ * The label of the tag
34838
+ *
34839
+ * @type {string}
34840
+ *
34841
+ *
34842
+ * @remarks
34843
+ * This key constant provides type-safe access to the `label` property of TagEnriched objects.
34844
+ * Use this constant when you need to access properties dynamically or ensure type safety.
34845
+ *
34846
+ * @example
34847
+ * ```typescript
34848
+ * // Direct property access
34849
+ * const value = tagenriched[KEY_TAG_ENRICHED_LABEL];
34850
+ *
34851
+ * // Dynamic property access
34852
+ * const propertyName = KEY_TAG_ENRICHED_LABEL;
34853
+ * const value = tagenriched[propertyName];
34854
+ * ```
34855
+ *
34856
+ * @see {@link TagEnriched} - The TypeScript type definition
34857
+ * @see {@link KEYS_TAG_ENRICHED} - Array of all keys for this type
34858
+ */
34859
+ export const KEY_TAG_ENRICHED_LABEL: keyof TagEnriched = 'label';
34860
+ /**
34861
+ * Tag Id
34862
+ *
34863
+ * The unique identifier of the tag
34864
+ *
34865
+ * @type {string}
34866
+ *
34867
+ *
34868
+ * @remarks
34869
+ * This key constant provides type-safe access to the `tag_id` property of TagEnriched objects.
34870
+ * Use this constant when you need to access properties dynamically or ensure type safety.
34871
+ *
34872
+ * @example
34873
+ * ```typescript
34874
+ * // Direct property access
34875
+ * const value = tagenriched[KEY_TAG_ENRICHED_TAG_ID];
34876
+ *
34877
+ * // Dynamic property access
34878
+ * const propertyName = KEY_TAG_ENRICHED_TAG_ID;
34879
+ * const value = tagenriched[propertyName];
34880
+ * ```
34881
+ *
34882
+ * @see {@link TagEnriched} - The TypeScript type definition
34883
+ * @see {@link KEYS_TAG_ENRICHED} - Array of all keys for this type
34884
+ */
34885
+ export const KEY_TAG_ENRICHED_TAG_ID: keyof TagEnriched = 'tag_id';
34886
+
34887
+ /**
34888
+ * Array of all TagEnriched property keys
34889
+ *
34890
+ * @remarks
34891
+ * This constant provides a readonly array containing all valid property keys for TagEnriched objects.
34892
+ * Useful for iteration, validation, and generating dynamic UI components.
34893
+ *
34894
+ * @example
34895
+ * ```typescript
34896
+ * // Iterating through all keys
34897
+ * for (const key of KEYS_TAG_ENRICHED) {
34898
+ * console.log(`Property: ${key}, Value: ${tagenriched[key]}`);
34899
+ * }
34900
+ *
34901
+ * // Validation
34902
+ * const isValidKey = KEYS_TAG_ENRICHED.includes(someKey);
34903
+ * ```
34904
+ *
34905
+ * @see {@link TagEnriched} - The TypeScript type definition
34906
+ */
34907
+ export const KEYS_TAG_ENRICHED = [
34908
+ KEY_TAG_ENRICHED_COLOR,
34909
+ KEY_TAG_ENRICHED_LABEL,
34910
+ KEY_TAG_ENRICHED_TAG_ID,
34911
+ ] as const satisfies (keyof TagEnriched)[];
34912
+
34963
34913
  /**
34964
34914
  * color property
34965
34915
  *
@@ -36152,158 +36102,6 @@ export const KEYS_TRADEMARK_CLAIMS_BASE = [
36152
36102
  KEY_TRADEMARK_CLAIMS_BASE_TMCH_REQUIRED,
36153
36103
  ] as const satisfies (keyof TrademarkClaimsBase)[];
36154
36104
 
36155
- /**
36156
- * Current Registrar
36157
- *
36158
- *
36159
- * @type {string}
36160
- *
36161
- *
36162
- * @remarks
36163
- * This key constant provides type-safe access to the `current_registrar` property of TransferEvent objects.
36164
- * Use this constant when you need to access properties dynamically or ensure type safety.
36165
- *
36166
- * @example
36167
- * ```typescript
36168
- * // Direct property access
36169
- * const value = transferevent[KEY_TRANSFER_EVENT_CURRENT_REGISTRAR];
36170
- *
36171
- * // Dynamic property access
36172
- * const propertyName = KEY_TRANSFER_EVENT_CURRENT_REGISTRAR;
36173
- * const value = transferevent[propertyName];
36174
- * ```
36175
- *
36176
- * @see {@link TransferEvent} - The TypeScript type definition
36177
- * @see {@link KEYS_TRANSFER_EVENT} - Array of all keys for this type
36178
- */
36179
- export const KEY_TRANSFER_EVENT_CURRENT_REGISTRAR: keyof TransferEvent = 'current_registrar';
36180
- /**
36181
- * execution_date property
36182
- *
36183
- *
36184
- *
36185
- *
36186
- * @remarks
36187
- * This key constant provides type-safe access to the `execution_date` property of TransferEvent objects.
36188
- * Use this constant when you need to access properties dynamically or ensure type safety.
36189
- *
36190
- * @example
36191
- * ```typescript
36192
- * // Direct property access
36193
- * const value = transferevent[KEY_TRANSFER_EVENT_EXECUTION_DATE];
36194
- *
36195
- * // Dynamic property access
36196
- * const propertyName = KEY_TRANSFER_EVENT_EXECUTION_DATE;
36197
- * const value = transferevent[propertyName];
36198
- * ```
36199
- *
36200
- * @see {@link TransferEvent} - The TypeScript type definition
36201
- * @see {@link KEYS_TRANSFER_EVENT} - Array of all keys for this type
36202
- */
36203
- export const KEY_TRANSFER_EVENT_EXECUTION_DATE: keyof TransferEvent = 'execution_date';
36204
- /**
36205
- * expiration_date property
36206
- *
36207
- *
36208
- *
36209
- *
36210
- * @remarks
36211
- * This key constant provides type-safe access to the `expiration_date` property of TransferEvent objects.
36212
- * Use this constant when you need to access properties dynamically or ensure type safety.
36213
- *
36214
- * @example
36215
- * ```typescript
36216
- * // Direct property access
36217
- * const value = transferevent[KEY_TRANSFER_EVENT_EXPIRATION_DATE];
36218
- *
36219
- * // Dynamic property access
36220
- * const propertyName = KEY_TRANSFER_EVENT_EXPIRATION_DATE;
36221
- * const value = transferevent[propertyName];
36222
- * ```
36223
- *
36224
- * @see {@link TransferEvent} - The TypeScript type definition
36225
- * @see {@link KEYS_TRANSFER_EVENT} - Array of all keys for this type
36226
- */
36227
- export const KEY_TRANSFER_EVENT_EXPIRATION_DATE: keyof TransferEvent = 'expiration_date';
36228
- /**
36229
- * Message
36230
- *
36231
- *
36232
- * @type {string}
36233
- *
36234
- *
36235
- * @remarks
36236
- * This key constant provides type-safe access to the `message` property of TransferEvent objects.
36237
- * Use this constant when you need to access properties dynamically or ensure type safety.
36238
- *
36239
- * @example
36240
- * ```typescript
36241
- * // Direct property access
36242
- * const value = transferevent[KEY_TRANSFER_EVENT_MESSAGE];
36243
- *
36244
- * // Dynamic property access
36245
- * const propertyName = KEY_TRANSFER_EVENT_MESSAGE;
36246
- * const value = transferevent[propertyName];
36247
- * ```
36248
- *
36249
- * @see {@link TransferEvent} - The TypeScript type definition
36250
- * @see {@link KEYS_TRANSFER_EVENT} - Array of all keys for this type
36251
- */
36252
- export const KEY_TRANSFER_EVENT_MESSAGE: keyof TransferEvent = 'message';
36253
- /**
36254
- * Requesting Registrar
36255
- *
36256
- *
36257
- * @type {string}
36258
- *
36259
- *
36260
- * @remarks
36261
- * This key constant provides type-safe access to the `requesting_registrar` property of TransferEvent objects.
36262
- * Use this constant when you need to access properties dynamically or ensure type safety.
36263
- *
36264
- * @example
36265
- * ```typescript
36266
- * // Direct property access
36267
- * const value = transferevent[KEY_TRANSFER_EVENT_REQUESTING_REGISTRAR];
36268
- *
36269
- * // Dynamic property access
36270
- * const propertyName = KEY_TRANSFER_EVENT_REQUESTING_REGISTRAR;
36271
- * const value = transferevent[propertyName];
36272
- * ```
36273
- *
36274
- * @see {@link TransferEvent} - The TypeScript type definition
36275
- * @see {@link KEYS_TRANSFER_EVENT} - Array of all keys for this type
36276
- */
36277
- export const KEY_TRANSFER_EVENT_REQUESTING_REGISTRAR: keyof TransferEvent = 'requesting_registrar';
36278
-
36279
- /**
36280
- * Array of all TransferEvent property keys
36281
- *
36282
- * @remarks
36283
- * This constant provides a readonly array containing all valid property keys for TransferEvent objects.
36284
- * Useful for iteration, validation, and generating dynamic UI components.
36285
- *
36286
- * @example
36287
- * ```typescript
36288
- * // Iterating through all keys
36289
- * for (const key of KEYS_TRANSFER_EVENT) {
36290
- * console.log(`Property: ${key}, Value: ${transferevent[key]}`);
36291
- * }
36292
- *
36293
- * // Validation
36294
- * const isValidKey = KEYS_TRANSFER_EVENT.includes(someKey);
36295
- * ```
36296
- *
36297
- * @see {@link TransferEvent} - The TypeScript type definition
36298
- */
36299
- export const KEYS_TRANSFER_EVENT = [
36300
- KEY_TRANSFER_EVENT_CURRENT_REGISTRAR,
36301
- KEY_TRANSFER_EVENT_EXECUTION_DATE,
36302
- KEY_TRANSFER_EVENT_EXPIRATION_DATE,
36303
- KEY_TRANSFER_EVENT_MESSAGE,
36304
- KEY_TRANSFER_EVENT_REQUESTING_REGISTRAR,
36305
- ] as const satisfies (keyof TransferEvent)[];
36306
-
36307
36105
  /**
36308
36106
  * Supported By Registrar
36309
36107
  *