1pub struct BinaryResponse {
2 pub content: bytes::Bytes,
3}
4#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5pub struct ErrorField {
6 pub code: String,
7 #[serde(skip_serializing_if = "Option::is_none")]
8 pub message: Option<String>,
9 pub path: String,
10 #[serde(rename = "pathRelated")]
11 #[serde(skip_serializing_if = "Option::is_none")]
12 pub path_related: Option<String>,
13}
14#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
15pub struct ErrorLimit {
16 pub code: String,
17 #[serde(skip_serializing_if = "Option::is_none")]
18 pub fields: Option<Vec<ErrorField>>,
19 #[serde(skip_serializing_if = "Option::is_none")]
20 pub message: Option<String>,
21 #[serde(rename = "retryAfterSec")]
22 pub retry_after_sec: i64,
23}
24#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
25pub struct Address {
26 pub address1: String,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub address2: Option<String>,
29 pub city: String,
30 pub country: AddressCountryEnum,
31 #[serde(rename = "postalCode")]
32 pub postal_code: String,
33 pub state: String,
34}
35#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
36pub struct LegalAgreement {
37 #[serde(rename = "agreementKey")]
38 pub agreement_key: String,
39 pub content: String,
40 pub title: String,
41 #[serde(skip_serializing_if = "Option::is_none")]
42 pub url: Option<String>,
43}
44#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
45pub struct DomainAvailableResponse {
46 pub available: bool,
47 #[serde(skip_serializing_if = "Option::is_none")]
48 pub currency: Option<String>,
49 pub definitive: bool,
50 pub domain: String,
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub period: Option<i64>,
53 #[serde(skip_serializing_if = "Option::is_none")]
54 pub price: Option<i64>,
55}
56#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
57pub struct JsonSchema {
58 pub id: String,
59 pub models: serde_json::Value,
60 pub properties: serde_json::Value,
61 pub required: Vec<String>,
62}
63#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
64pub struct DomainSuggestion {
65 pub domain: String,
66}
67#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
68pub struct TldSummary {
69 pub name: String,
70 #[serde(rename = "type")]
71 pub type_field: TldSummaryTypeEnum,
72}
73#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
74pub struct VerificationDomainName {
75 pub status: VerificationDomainNameStatusEnum,
76}
77#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
78pub struct VerificationRealName {
79 pub status: VerificationRealNameStatusEnum,
80}
81#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
82pub struct DnsRecord {
83 pub data: String,
84 pub name: String,
85 #[serde(skip_serializing_if = "Option::is_none")]
86 pub port: Option<i64>,
87 #[serde(skip_serializing_if = "Option::is_none")]
88 pub priority: Option<i64>,
89 #[serde(skip_serializing_if = "Option::is_none")]
90 pub protocol: Option<String>,
91 #[serde(skip_serializing_if = "Option::is_none")]
92 pub service: Option<String>,
93 #[serde(skip_serializing_if = "Option::is_none")]
94 pub ttl: Option<i64>,
95 #[serde(rename = "type")]
96 pub type_field: DnsRecordTypeEnum,
97 #[serde(skip_serializing_if = "Option::is_none")]
98 pub weight: Option<i64>,
99}
100#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
101pub struct DomainForwardingMask {
102 #[serde(skip_serializing_if = "Option::is_none")]
103 pub description: Option<String>,
104 #[serde(skip_serializing_if = "Option::is_none")]
105 pub keywords: Option<String>,
106 #[serde(skip_serializing_if = "Option::is_none")]
107 pub title: Option<String>,
108}
109#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
110pub struct DomainNotification {
111 #[serde(rename = "addedAt")]
112 pub added_at: String,
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub metadata: Option<serde_json::Value>,
115 #[serde(rename = "notificationId")]
116 pub notification_id: String,
117 #[serde(rename = "requestId")]
118 #[serde(skip_serializing_if = "Option::is_none")]
119 pub request_id: Option<String>,
120 pub resource: String,
121 #[serde(rename = "resourceType")]
122 pub resource_type: DomainNotificationResourceTypeEnum,
123 pub status: DomainNotificationStatusEnum,
124 #[serde(rename = "type")]
125 pub type_field: DomainNotificationTypeEnum,
126}
127#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
128pub struct ActionReason {
129 pub code: String,
130 #[serde(skip_serializing_if = "Option::is_none")]
131 pub fields: Option<Vec<ErrorField>>,
132 #[serde(skip_serializing_if = "Option::is_none")]
133 pub message: Option<String>,
134 #[serde(flatten)]
135 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
136}
137#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
138pub struct ContactDomain {
139 #[serde(rename = "_createdAt")]
140 #[serde(skip_serializing_if = "Option::is_none")]
141 pub created_at: Option<String>,
142 #[serde(rename = "_deleted")]
143 #[serde(skip_serializing_if = "Option::is_none")]
144 pub deleted: Option<bool>,
145 #[serde(rename = "_modifiedAt")]
146 #[serde(skip_serializing_if = "Option::is_none")]
147 pub modified_at: Option<String>,
148 #[serde(rename = "_revision")]
149 #[serde(skip_serializing_if = "Option::is_none")]
150 pub revision: Option<i64>,
151 #[serde(rename = "addressMailing")]
152 pub address_mailing: Address,
153 #[serde(rename = "contactId")]
154 #[serde(skip_serializing_if = "Option::is_none")]
155 pub contact_id: Option<String>,
156 pub email: String,
157 #[serde(skip_serializing_if = "Option::is_none")]
158 pub encoding: Option<ContactDomainEncodingEnum>,
159 #[serde(rename = "exposeWhois")]
160 pub expose_whois: bool,
161 #[serde(skip_serializing_if = "Option::is_none")]
162 pub fax: Option<String>,
163 #[serde(rename = "jobTitle")]
164 #[serde(skip_serializing_if = "Option::is_none")]
165 pub job_title: Option<String>,
166 #[serde(skip_serializing_if = "Option::is_none")]
167 pub metadata: Option<serde_json::Value>,
168 #[serde(rename = "nameFirst")]
169 pub name_first: String,
170 #[serde(rename = "nameLast")]
171 pub name_last: String,
172 #[serde(rename = "nameMiddle")]
173 #[serde(skip_serializing_if = "Option::is_none")]
174 pub name_middle: Option<String>,
175 #[serde(skip_serializing_if = "Option::is_none")]
176 pub organization: Option<String>,
177 pub phone: String,
178 #[serde(skip_serializing_if = "Option::is_none")]
179 pub tlds: Option<Vec<String>>,
180}
181#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
182pub struct DomainDnssec {
183 pub algorithm: DomainDnssecAlgorithmEnum,
184 #[serde(skip_serializing_if = "Option::is_none")]
185 pub digest: Option<String>,
186 #[serde(rename = "digestType")]
187 #[serde(skip_serializing_if = "Option::is_none")]
188 pub digest_type: Option<DomainDnssecDigestTypeEnum>,
189 #[serde(skip_serializing_if = "Option::is_none")]
190 pub flags: Option<DomainDnssecFlagsEnum>,
191 #[serde(rename = "keyTag")]
192 #[serde(skip_serializing_if = "Option::is_none")]
193 pub key_tag: Option<i64>,
194 #[serde(rename = "maxSignatureLife")]
195 #[serde(skip_serializing_if = "Option::is_none")]
196 pub max_signature_life: Option<i64>,
197 #[serde(rename = "publicKey")]
198 #[serde(skip_serializing_if = "Option::is_none")]
199 pub public_key: Option<String>,
200}
201#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
202pub struct RenewalDetails {
203 pub currency: String,
204 pub price: i64,
205 #[serde(skip_serializing_if = "Option::is_none")]
206 pub renewable: Option<bool>,
207}
208#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
209pub struct VerificationsDomainV2 {
210 #[serde(rename = "domainName")]
211 #[serde(skip_serializing_if = "Option::is_none")]
212 pub domain_name: Option<VerificationsDomainV2DomainNameEnum>,
213 #[serde(skip_serializing_if = "Option::is_none")]
214 pub icann: Option<VerificationsDomainV2IcannEnum>,
215 #[serde(rename = "realName")]
216 #[serde(skip_serializing_if = "Option::is_none")]
217 pub real_name: Option<VerificationsDomainV2RealNameEnum>,
218 #[serde(flatten)]
219 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
220}
221#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
222pub struct ContactRegistrantChange {
223 pub email: String,
224 #[serde(rename = "firstName")]
225 pub first_name: String,
226 #[serde(rename = "lastName")]
227 pub last_name: String,
228 #[serde(skip_serializing_if = "Option::is_none")]
229 pub organization: Option<String>,
230}
231#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
232pub struct DomainPrivacyForwarding {
233 #[serde(rename = "emailPreference")]
234 #[serde(skip_serializing_if = "Option::is_none")]
235 pub email_preference: Option<DomainPrivacyForwardingEmailPreferenceEnum>,
236 #[serde(rename = "forwardingEmail")]
237 #[serde(skip_serializing_if = "Option::is_none")]
238 pub forwarding_email: Option<String>,
239 #[serde(rename = "privateEmail")]
240 #[serde(skip_serializing_if = "Option::is_none")]
241 pub private_email: Option<String>,
242}
243#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
244pub struct Maintenance {
245 #[serde(rename = "createdAt")]
246 pub created_at: String,
247 #[serde(rename = "endsAt")]
248 pub ends_at: String,
249 pub environment: MaintenanceEnvironmentEnum,
250 #[serde(rename = "maintenanceId")]
251 pub maintenance_id: String,
252 #[serde(rename = "modifiedAt")]
253 pub modified_at: String,
254 pub reason: MaintenanceReasonEnum,
255 #[serde(rename = "startsAt")]
256 pub starts_at: String,
257 pub status: MaintenanceStatusEnum,
258 pub summary: String,
259 #[serde(skip_serializing_if = "Option::is_none")]
260 pub tlds: Option<Vec<String>>,
261 #[serde(rename = "type")]
262 pub type_field: MaintenanceTypeEnum,
263 #[serde(flatten)]
264 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
265}
266#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
267pub struct MaintenanceSystem {
268 pub impact: Vec<MaintenanceSystemImpactItemEnum>,
269 pub name: MaintenanceSystemNameEnum,
270 #[serde(flatten)]
271 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
272}
273#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
274pub struct ConsentDomainUpdate {
275 #[serde(rename = "agreedAt")]
276 pub agreed_at: String,
277 #[serde(rename = "agreedBy")]
278 pub agreed_by: String,
279 #[serde(rename = "agreementKeys")]
280 pub agreement_keys: Vec<ConsentDomainUpdateAgreementKeysItemEnum>,
281}
282#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
283pub struct DomainPrivacyForwardingUpdate {
284 #[serde(rename = "emailPreference")]
285 pub email_preference: DomainPrivacyForwardingUpdateEmailPreferenceEnum,
286 #[serde(rename = "forwardingEmail")]
287 #[serde(skip_serializing_if = "Option::is_none")]
288 pub forwarding_email: Option<String>,
289 #[serde(rename = "privateEmailType")]
290 pub private_email_type: DomainPrivacyForwardingUpdatePrivateEmailTypeEnum,
291}
292#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
293pub struct DomainAvailableBulk {
294 pub domains: Vec<DomainAvailableResponse>,
295}
296#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
297pub struct DomainAvailableError {
298 pub code: String,
299 pub domain: String,
300 #[serde(skip_serializing_if = "Option::is_none")]
301 pub message: Option<String>,
302 pub path: String,
303 pub status: i64,
304}
305#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
306pub struct ErrorFieldDomainContactsValidate {
307 pub code: String,
308 pub domains: Vec<String>,
309 #[serde(skip_serializing_if = "Option::is_none")]
310 pub message: Option<String>,
311 pub path: String,
312 #[serde(rename = "pathRelated")]
313 #[serde(skip_serializing_if = "Option::is_none")]
314 pub path_related: Option<String>,
315}
316#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
317pub struct Consent {
318 #[serde(rename = "agreedAt")]
319 pub agreed_at: String,
320 #[serde(rename = "agreedBy")]
321 pub agreed_by: String,
322 #[serde(rename = "agreementKeys")]
323 pub agreement_keys: Vec<String>,
324}
325#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
326pub struct DomainPurchaseResponse {
327 #[serde(skip_serializing_if = "Option::is_none")]
328 pub currency: Option<String>,
329 #[serde(rename = "itemCount")]
330 pub item_count: i64,
331 #[serde(rename = "orderId")]
332 pub order_id: i64,
333 pub total: i64,
334}
335#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
336pub struct PrivacyPurchase {
337 pub consent: Consent,
338}
339#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
340pub struct DomainRenew {
341 #[serde(skip_serializing_if = "Option::is_none")]
342 pub period: Option<i64>,
343}
344#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
345pub struct DomainForwardingCreate {
346 #[serde(skip_serializing_if = "Option::is_none")]
347 pub mask: Option<DomainForwardingMask>,
348 #[serde(rename = "type")]
349 pub type_field: DomainForwardingCreateTypeEnum,
350 pub url: String,
351}
352#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
353pub struct ConsentV2 {
354 #[serde(rename = "agreedAt")]
355 pub agreed_at: String,
356 #[serde(rename = "agreedBy")]
357 pub agreed_by: String,
358 #[serde(rename = "agreementKeys")]
359 pub agreement_keys: Vec<String>,
360 #[serde(rename = "claimToken")]
361 #[serde(skip_serializing_if = "Option::is_none")]
362 pub claim_token: Option<String>,
363 pub currency: String,
364 pub price: i64,
365 #[serde(rename = "registryPremiumPricing")]
366 #[serde(skip_serializing_if = "Option::is_none")]
367 pub registry_premium_pricing: Option<bool>,
368 #[serde(flatten)]
369 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
370}
371#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
372pub struct ContactDomainCreate {
373 #[serde(rename = "addressMailing")]
374 pub address_mailing: Address,
375 pub email: String,
376 pub encoding: ContactDomainCreateEncodingEnum,
377 #[serde(skip_serializing_if = "Option::is_none")]
378 pub fax: Option<String>,
379 #[serde(rename = "jobTitle")]
380 #[serde(skip_serializing_if = "Option::is_none")]
381 pub job_title: Option<String>,
382 #[serde(skip_serializing_if = "Option::is_none")]
383 pub metadata: Option<serde_json::Value>,
384 #[serde(rename = "nameFirst")]
385 pub name_first: String,
386 #[serde(rename = "nameLast")]
387 pub name_last: String,
388 #[serde(rename = "nameMiddle")]
389 #[serde(skip_serializing_if = "Option::is_none")]
390 pub name_middle: Option<String>,
391 #[serde(skip_serializing_if = "Option::is_none")]
392 pub organization: Option<String>,
393 pub phone: String,
394 #[serde(flatten)]
395 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
396}
397#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
398pub struct ConsentRedemption {
399 #[serde(rename = "agreedAt")]
400 pub agreed_at: String,
401 #[serde(rename = "agreedBy")]
402 pub agreed_by: String,
403 pub currency: String,
404 pub fee: i64,
405 pub price: i64,
406 #[serde(flatten)]
407 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
408}
409#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
410pub struct ConsentRenew {
411 #[serde(rename = "agreedAt")]
412 pub agreed_at: String,
413 #[serde(rename = "agreedBy")]
414 pub agreed_by: String,
415 pub currency: String,
416 pub price: i64,
417 #[serde(rename = "registryPremiumPricing")]
418 #[serde(skip_serializing_if = "Option::is_none")]
419 pub registry_premium_pricing: Option<bool>,
420 #[serde(flatten)]
421 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
422}
423#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
424pub struct DomainTransferAuthCode {
425 #[serde(rename = "authCode")]
426 pub auth_code: String,
427 #[serde(flatten)]
428 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
429}
430#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
431pub struct DnsRecordCreateType {
432 pub data: String,
433 pub name: String,
434 #[serde(skip_serializing_if = "Option::is_none")]
435 pub port: Option<i64>,
436 #[serde(skip_serializing_if = "Option::is_none")]
437 pub priority: Option<i64>,
438 #[serde(skip_serializing_if = "Option::is_none")]
439 pub protocol: Option<String>,
440 #[serde(skip_serializing_if = "Option::is_none")]
441 pub service: Option<String>,
442 #[serde(skip_serializing_if = "Option::is_none")]
443 pub ttl: Option<i64>,
444 #[serde(skip_serializing_if = "Option::is_none")]
445 pub weight: Option<i64>,
446}
447#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
448pub struct DnsRecordCreateTypeName {
449 pub data: String,
450 #[serde(skip_serializing_if = "Option::is_none")]
451 pub port: Option<i64>,
452 #[serde(skip_serializing_if = "Option::is_none")]
453 pub priority: Option<i64>,
454 #[serde(skip_serializing_if = "Option::is_none")]
455 pub protocol: Option<String>,
456 #[serde(skip_serializing_if = "Option::is_none")]
457 pub service: Option<String>,
458 #[serde(skip_serializing_if = "Option::is_none")]
459 pub ttl: Option<i64>,
460 #[serde(skip_serializing_if = "Option::is_none")]
461 pub weight: Option<i64>,
462}
463#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
464pub struct DomainNameServerUpdateV2 {
465 #[serde(rename = "nameServers")]
466 #[serde(skip_serializing_if = "Option::is_none")]
467 pub name_servers: Option<Vec<String>>,
468 #[serde(flatten)]
469 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
470}
471#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
472pub struct Error {
473 pub code: String,
474 #[serde(skip_serializing_if = "Option::is_none")]
475 pub fields: Option<Vec<ErrorField>>,
476 #[serde(skip_serializing_if = "Option::is_none")]
477 pub message: Option<String>,
478}
479#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
480pub struct Contact {
481 #[serde(rename = "addressMailing")]
482 pub address_mailing: Address,
483 pub email: String,
484 #[serde(skip_serializing_if = "Option::is_none")]
485 pub fax: Option<String>,
486 #[serde(rename = "jobTitle")]
487 #[serde(skip_serializing_if = "Option::is_none")]
488 pub job_title: Option<String>,
489 #[serde(rename = "nameFirst")]
490 pub name_first: String,
491 #[serde(rename = "nameLast")]
492 pub name_last: String,
493 #[serde(rename = "nameMiddle")]
494 #[serde(skip_serializing_if = "Option::is_none")]
495 pub name_middle: Option<String>,
496 #[serde(skip_serializing_if = "Option::is_none")]
497 pub organization: Option<String>,
498 pub phone: String,
499}
500#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
501pub struct VerificationsDomain {
502 #[serde(rename = "domainName")]
503 #[serde(skip_serializing_if = "Option::is_none")]
504 pub domain_name: Option<VerificationDomainName>,
505 #[serde(rename = "realName")]
506 #[serde(skip_serializing_if = "Option::is_none")]
507 pub real_name: Option<VerificationRealName>,
508}
509#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
510pub struct DomainForwarding {
511 pub fqdn: String,
512 #[serde(skip_serializing_if = "Option::is_none")]
513 pub mask: Option<DomainForwardingMask>,
514 #[serde(rename = "type")]
515 pub type_field: DomainForwardingTypeEnum,
516 pub url: String,
517}
518#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
519pub struct Action {
520 #[serde(rename = "completedAt")]
521 #[serde(skip_serializing_if = "Option::is_none")]
522 pub completed_at: Option<String>,
523 #[serde(rename = "createdAt")]
524 pub created_at: String,
525 #[serde(rename = "modifiedAt")]
526 #[serde(skip_serializing_if = "Option::is_none")]
527 pub modified_at: Option<String>,
528 pub origination: ActionOriginationEnum,
529 #[serde(skip_serializing_if = "Option::is_none")]
530 pub reason: Option<ActionReason>,
531 #[serde(rename = "requestId")]
532 #[serde(skip_serializing_if = "Option::is_none")]
533 pub request_id: Option<String>,
534 #[serde(rename = "startedAt")]
535 #[serde(skip_serializing_if = "Option::is_none")]
536 pub started_at: Option<String>,
537 pub status: ActionStatusEnum,
538 #[serde(rename = "type")]
539 pub type_field: ActionTypeEnum,
540}
541#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
542pub struct DomainContactsV2 {
543 #[serde(skip_serializing_if = "Option::is_none")]
544 pub admin: Option<ContactDomain>,
545 #[serde(skip_serializing_if = "Option::is_none")]
546 pub billing: Option<ContactDomain>,
547 #[serde(skip_serializing_if = "Option::is_none")]
548 pub registrant: Option<ContactDomain>,
549 #[serde(skip_serializing_if = "Option::is_none")]
550 pub tech: Option<ContactDomain>,
551 #[serde(flatten)]
552 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
553}
554#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
555pub struct DomainChangeOfRegistrant {
556 #[serde(rename = "createDate")]
557 pub create_date: String,
558 #[serde(rename = "gainingContact")]
559 pub gaining_contact: ContactRegistrantChange,
560 #[serde(rename = "losingContact")]
561 pub losing_contact: ContactRegistrantChange,
562 #[serde(rename = "otherDomainsAffected")]
563 #[serde(skip_serializing_if = "Option::is_none")]
564 pub other_domains_affected: Option<i64>,
565 #[serde(rename = "shopperEmail")]
566 #[serde(skip_serializing_if = "Option::is_none")]
567 pub shopper_email: Option<String>,
568}
569#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
570pub struct MaintenanceDetail {
571 #[serde(rename = "createdAt")]
572 pub created_at: String,
573 #[serde(rename = "endsAt")]
574 pub ends_at: String,
575 pub environment: MaintenanceDetailEnvironmentEnum,
576 #[serde(rename = "maintenanceId")]
577 pub maintenance_id: String,
578 #[serde(rename = "modifiedAt")]
579 pub modified_at: String,
580 pub reason: MaintenanceDetailReasonEnum,
581 #[serde(rename = "startsAt")]
582 pub starts_at: String,
583 pub status: MaintenanceDetailStatusEnum,
584 pub summary: String,
585 #[serde(skip_serializing_if = "Option::is_none")]
586 pub systems: Option<Vec<MaintenanceSystem>>,
587 #[serde(skip_serializing_if = "Option::is_none")]
588 pub tlds: Option<Vec<String>>,
589 #[serde(rename = "type")]
590 pub type_field: MaintenanceDetailTypeEnum,
591 #[serde(flatten)]
592 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
593}
594#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
595pub struct DomainUpdate {
596 #[serde(skip_serializing_if = "Option::is_none")]
597 pub consent: Option<ConsentDomainUpdate>,
598 #[serde(rename = "exposeWhois")]
599 #[serde(skip_serializing_if = "Option::is_none")]
600 pub expose_whois: Option<bool>,
601 #[serde(skip_serializing_if = "Option::is_none")]
602 pub locked: Option<bool>,
603 #[serde(rename = "nameServers")]
604 #[serde(skip_serializing_if = "Option::is_none")]
605 pub name_servers: Option<Vec<serde_json::Value>>,
606 #[serde(rename = "renewAuto")]
607 #[serde(skip_serializing_if = "Option::is_none")]
608 pub renew_auto: Option<bool>,
609 #[serde(rename = "subaccountId")]
610 #[serde(skip_serializing_if = "Option::is_none")]
611 pub subaccount_id: Option<String>,
612}
613#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
614pub struct DomainContacts {
615 #[serde(rename = "contactAdmin")]
616 #[serde(skip_serializing_if = "Option::is_none")]
617 pub contact_admin: Option<Contact>,
618 #[serde(rename = "contactBilling")]
619 #[serde(skip_serializing_if = "Option::is_none")]
620 pub contact_billing: Option<Contact>,
621 #[serde(rename = "contactRegistrant")]
622 pub contact_registrant: Contact,
623 #[serde(rename = "contactTech")]
624 #[serde(skip_serializing_if = "Option::is_none")]
625 pub contact_tech: Option<Contact>,
626}
627#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
628pub struct DomainAvailableBulkMixed {
629 pub domains: Vec<DomainAvailableResponse>,
630 #[serde(skip_serializing_if = "Option::is_none")]
631 pub errors: Option<Vec<DomainAvailableError>>,
632}
633#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
634pub struct DomainsContactsBulk {
635 #[serde(rename = "contactAdmin")]
636 #[serde(skip_serializing_if = "Option::is_none")]
637 pub contact_admin: Option<Contact>,
638 #[serde(rename = "contactBilling")]
639 #[serde(skip_serializing_if = "Option::is_none")]
640 pub contact_billing: Option<Contact>,
641 #[serde(rename = "contactPresence")]
642 #[serde(skip_serializing_if = "Option::is_none")]
643 pub contact_presence: Option<Contact>,
644 #[serde(rename = "contactRegistrant")]
645 #[serde(skip_serializing_if = "Option::is_none")]
646 pub contact_registrant: Option<Contact>,
647 #[serde(rename = "contactTech")]
648 #[serde(skip_serializing_if = "Option::is_none")]
649 pub contact_tech: Option<Contact>,
650 pub domains: Vec<String>,
651 #[serde(rename = "entityType")]
652 #[serde(skip_serializing_if = "Option::is_none")]
653 pub entity_type: Option<DomainsContactsBulkEntityTypeEnum>,
654}
655#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
656pub struct ErrorDomainContactsValidate {
657 pub code: String,
658 #[serde(skip_serializing_if = "Option::is_none")]
659 pub fields: Option<Vec<ErrorFieldDomainContactsValidate>>,
660 #[serde(skip_serializing_if = "Option::is_none")]
661 pub message: Option<String>,
662 #[serde(skip_serializing_if = "Option::is_none")]
663 pub stack: Option<Vec<String>>,
664}
665#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
666pub struct DomainPurchase {
667 pub consent: Consent,
668 #[serde(rename = "contactAdmin")]
669 #[serde(skip_serializing_if = "Option::is_none")]
670 pub contact_admin: Option<Contact>,
671 #[serde(rename = "contactBilling")]
672 #[serde(skip_serializing_if = "Option::is_none")]
673 pub contact_billing: Option<Contact>,
674 #[serde(rename = "contactRegistrant")]
675 #[serde(skip_serializing_if = "Option::is_none")]
676 pub contact_registrant: Option<Contact>,
677 #[serde(rename = "contactTech")]
678 #[serde(skip_serializing_if = "Option::is_none")]
679 pub contact_tech: Option<Contact>,
680 pub domain: String,
681 #[serde(rename = "nameServers")]
682 #[serde(skip_serializing_if = "Option::is_none")]
683 pub name_servers: Option<Vec<String>>,
684 #[serde(skip_serializing_if = "Option::is_none")]
685 pub period: Option<i64>,
686 #[serde(skip_serializing_if = "Option::is_none")]
687 pub privacy: Option<bool>,
688 #[serde(rename = "renewAuto")]
689 #[serde(skip_serializing_if = "Option::is_none")]
690 pub renew_auto: Option<bool>,
691}
692#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
693pub struct DomainTransferIn {
694 #[serde(rename = "authCode")]
695 pub auth_code: String,
696 pub consent: Consent,
697 #[serde(rename = "contactAdmin")]
698 #[serde(skip_serializing_if = "Option::is_none")]
699 pub contact_admin: Option<Contact>,
700 #[serde(rename = "contactBilling")]
701 #[serde(skip_serializing_if = "Option::is_none")]
702 pub contact_billing: Option<Contact>,
703 #[serde(rename = "contactRegistrant")]
704 #[serde(skip_serializing_if = "Option::is_none")]
705 pub contact_registrant: Option<Contact>,
706 #[serde(rename = "contactTech")]
707 #[serde(skip_serializing_if = "Option::is_none")]
708 pub contact_tech: Option<Contact>,
709 #[serde(skip_serializing_if = "Option::is_none")]
710 pub period: Option<i64>,
711 #[serde(skip_serializing_if = "Option::is_none")]
712 pub privacy: Option<bool>,
713 #[serde(rename = "renewAuto")]
714 #[serde(skip_serializing_if = "Option::is_none")]
715 pub renew_auto: Option<bool>,
716}
717#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
718pub struct DomainContactsCreateV2 {
719 #[serde(skip_serializing_if = "Option::is_none")]
720 pub admin: Option<ContactDomainCreate>,
721 #[serde(rename = "adminId")]
722 #[serde(skip_serializing_if = "Option::is_none")]
723 pub admin_id: Option<String>,
724 #[serde(skip_serializing_if = "Option::is_none")]
725 pub billing: Option<ContactDomainCreate>,
726 #[serde(rename = "billingId")]
727 #[serde(skip_serializing_if = "Option::is_none")]
728 pub billing_id: Option<String>,
729 #[serde(skip_serializing_if = "Option::is_none")]
730 pub registrant: Option<ContactDomainCreate>,
731 #[serde(rename = "registrantId")]
732 #[serde(skip_serializing_if = "Option::is_none")]
733 pub registrant_id: Option<String>,
734 #[serde(skip_serializing_if = "Option::is_none")]
735 pub tech: Option<ContactDomainCreate>,
736 #[serde(rename = "techId")]
737 #[serde(skip_serializing_if = "Option::is_none")]
738 pub tech_id: Option<String>,
739 #[serde(flatten)]
740 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
741}
742#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
743pub struct DomainRedeemV2 {
744 pub consent: ConsentRedemption,
745 #[serde(flatten)]
746 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
747}
748#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
749pub struct DomainRenewV2 {
750 pub consent: ConsentRenew,
751 pub expires: String,
752 #[serde(skip_serializing_if = "Option::is_none")]
753 pub period: Option<i64>,
754 #[serde(flatten)]
755 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
756}
757#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
758pub struct DomainTransferInV2 {
759 #[serde(rename = "authCode")]
760 pub auth_code: String,
761 pub consent: ConsentV2,
762 #[serde(skip_serializing_if = "Option::is_none")]
763 pub contacts: Option<DomainContactsCreateV2>,
764 #[serde(rename = "identityDocumentId")]
765 #[serde(skip_serializing_if = "Option::is_none")]
766 pub identity_document_id: Option<String>,
767 #[serde(skip_serializing_if = "Option::is_none")]
768 pub metadata: Option<serde_json::Value>,
769 #[serde(skip_serializing_if = "Option::is_none")]
770 pub period: Option<i64>,
771 #[serde(skip_serializing_if = "Option::is_none")]
772 pub privacy: Option<bool>,
773 #[serde(rename = "renewAuto")]
774 #[serde(skip_serializing_if = "Option::is_none")]
775 pub renew_auto: Option<bool>,
776 #[serde(flatten)]
777 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
778}
779#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
780pub struct DomainSummary {
781 #[serde(rename = "authCode")]
782 #[serde(skip_serializing_if = "Option::is_none")]
783 pub auth_code: Option<String>,
784 #[serde(rename = "contactAdmin")]
785 #[serde(skip_serializing_if = "Option::is_none")]
786 pub contact_admin: Option<Contact>,
787 #[serde(rename = "contactBilling")]
788 #[serde(skip_serializing_if = "Option::is_none")]
789 pub contact_billing: Option<Contact>,
790 #[serde(rename = "contactRegistrant")]
791 pub contact_registrant: Contact,
792 #[serde(rename = "contactTech")]
793 #[serde(skip_serializing_if = "Option::is_none")]
794 pub contact_tech: Option<Contact>,
795 #[serde(rename = "createdAt")]
796 pub created_at: String,
797 #[serde(rename = "deletedAt")]
798 #[serde(skip_serializing_if = "Option::is_none")]
799 pub deleted_at: Option<String>,
800 pub domain: String,
801 #[serde(rename = "domainId")]
802 pub domain_id: f64,
803 #[serde(rename = "expirationProtected")]
804 pub expiration_protected: bool,
805 #[serde(skip_serializing_if = "Option::is_none")]
806 pub expires: Option<String>,
807 #[serde(rename = "exposeWhois")]
808 #[serde(skip_serializing_if = "Option::is_none")]
809 pub expose_whois: Option<bool>,
810 #[serde(rename = "holdRegistrar")]
811 pub hold_registrar: bool,
812 pub locked: bool,
813 #[serde(rename = "nameServers")]
814 #[serde(skip_serializing_if = "Option::is_none")]
815 pub name_servers: Option<Vec<String>>,
816 pub privacy: bool,
817 #[serde(rename = "registrarCreatedAt")]
818 #[serde(skip_serializing_if = "Option::is_none")]
819 pub registrar_created_at: Option<String>,
820 #[serde(rename = "renewAuto")]
821 pub renew_auto: bool,
822 #[serde(rename = "renewDeadline")]
823 pub renew_deadline: String,
824 #[serde(skip_serializing_if = "Option::is_none")]
825 pub renewable: Option<bool>,
826 pub status: String,
827 #[serde(rename = "transferAwayEligibleAt")]
828 #[serde(skip_serializing_if = "Option::is_none")]
829 pub transfer_away_eligible_at: Option<String>,
830 #[serde(rename = "transferProtected")]
831 pub transfer_protected: bool,
832}
833#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
834pub struct DomainDetail {
835 #[serde(rename = "authCode")]
836 pub auth_code: String,
837 #[serde(rename = "contactAdmin")]
838 pub contact_admin: Contact,
839 #[serde(rename = "contactBilling")]
840 pub contact_billing: Contact,
841 #[serde(rename = "contactRegistrant")]
842 pub contact_registrant: Contact,
843 #[serde(rename = "contactTech")]
844 pub contact_tech: Contact,
845 #[serde(rename = "createdAt")]
846 pub created_at: String,
847 #[serde(rename = "deletedAt")]
848 #[serde(skip_serializing_if = "Option::is_none")]
849 pub deleted_at: Option<String>,
850 pub domain: String,
851 #[serde(rename = "domainId")]
852 pub domain_id: f64,
853 #[serde(rename = "expirationProtected")]
854 pub expiration_protected: bool,
855 #[serde(skip_serializing_if = "Option::is_none")]
856 pub expires: Option<String>,
857 #[serde(rename = "exposeWhois")]
858 #[serde(skip_serializing_if = "Option::is_none")]
859 pub expose_whois: Option<bool>,
860 #[serde(rename = "holdRegistrar")]
861 pub hold_registrar: bool,
862 pub locked: bool,
863 #[serde(rename = "nameServers")]
864 pub name_servers: Vec<String>,
865 pub privacy: bool,
866 #[serde(rename = "registrarCreatedAt")]
867 #[serde(skip_serializing_if = "Option::is_none")]
868 pub registrar_created_at: Option<String>,
869 #[serde(rename = "renewAuto")]
870 pub renew_auto: bool,
871 #[serde(rename = "renewDeadline")]
872 pub renew_deadline: String,
873 pub status: String,
874 #[serde(rename = "subaccountId")]
875 #[serde(skip_serializing_if = "Option::is_none")]
876 pub subaccount_id: Option<String>,
877 #[serde(rename = "transferAwayEligibleAt")]
878 #[serde(skip_serializing_if = "Option::is_none")]
879 pub transfer_away_eligible_at: Option<String>,
880 #[serde(rename = "transferProtected")]
881 pub transfer_protected: bool,
882 #[serde(skip_serializing_if = "Option::is_none")]
883 pub verifications: Option<VerificationsDomain>,
884}
885#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
886pub struct DomainDetailV2 {
887 #[serde(skip_serializing_if = "Option::is_none")]
888 pub actions: Option<Vec<Action>>,
889 #[serde(rename = "authCode")]
890 pub auth_code: String,
891 pub contacts: DomainContactsV2,
892 #[serde(rename = "createdAt")]
893 pub created_at: String,
894 #[serde(rename = "deletedAt")]
895 #[serde(skip_serializing_if = "Option::is_none")]
896 pub deleted_at: Option<String>,
897 #[serde(rename = "dnssecRecords")]
898 #[serde(skip_serializing_if = "Option::is_none")]
899 pub dnssec_records: Option<Vec<DomainDnssec>>,
900 pub domain: String,
901 #[serde(rename = "domainId")]
902 pub domain_id: String,
903 #[serde(rename = "expirationProtected")]
904 pub expiration_protected: bool,
905 #[serde(rename = "expiresAt")]
906 #[serde(skip_serializing_if = "Option::is_none")]
907 pub expires_at: Option<String>,
908 #[serde(rename = "holdRegistrar")]
909 pub hold_registrar: bool,
910 #[serde(skip_serializing_if = "Option::is_none")]
911 pub hostnames: Option<Vec<String>>,
912 pub locked: bool,
913 #[serde(rename = "modifiedAt")]
914 #[serde(skip_serializing_if = "Option::is_none")]
915 pub modified_at: Option<String>,
916 #[serde(rename = "nameServers")]
917 pub name_servers: Vec<String>,
918 pub privacy: bool,
919 #[serde(rename = "registrarCreatedAt")]
920 #[serde(skip_serializing_if = "Option::is_none")]
921 pub registrar_created_at: Option<String>,
922 #[serde(rename = "registryStatusCodes")]
923 #[serde(skip_serializing_if = "Option::is_none")]
924 pub registry_status_codes: Option<Vec<DomainDetailV2RegistryStatusCodesItemEnum>>,
925 #[serde(rename = "renewAuto")]
926 pub renew_auto: bool,
927 #[serde(rename = "renewDeadline")]
928 pub renew_deadline: String,
929 #[serde(skip_serializing_if = "Option::is_none")]
930 pub renewal: Option<RenewalDetails>,
931 pub status: DomainDetailV2StatusEnum,
932 #[serde(rename = "subaccountId")]
933 #[serde(skip_serializing_if = "Option::is_none")]
934 pub subaccount_id: Option<String>,
935 #[serde(rename = "transferAwayEligibleAt")]
936 #[serde(skip_serializing_if = "Option::is_none")]
937 pub transfer_away_eligible_at: Option<String>,
938 #[serde(rename = "transferProtected")]
939 pub transfer_protected: bool,
940 #[serde(skip_serializing_if = "Option::is_none")]
941 pub verifications: Option<VerificationsDomainV2>,
942 #[serde(flatten)]
943 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
944}
945#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
946pub struct DomainPurchaseV2 {
947 pub consent: ConsentV2,
948 #[serde(skip_serializing_if = "Option::is_none")]
949 pub contacts: Option<DomainContactsCreateV2>,
950 pub domain: String,
951 #[serde(skip_serializing_if = "Option::is_none")]
952 pub metadata: Option<serde_json::Value>,
953 #[serde(rename = "nameServers")]
954 #[serde(skip_serializing_if = "Option::is_none")]
955 pub name_servers: Option<Vec<String>>,
956 #[serde(skip_serializing_if = "Option::is_none")]
957 pub period: Option<i64>,
958 #[serde(skip_serializing_if = "Option::is_none")]
959 pub privacy: Option<bool>,
960 #[serde(rename = "renewAuto")]
961 #[serde(skip_serializing_if = "Option::is_none")]
962 pub renew_auto: Option<bool>,
963 #[serde(flatten)]
964 pub additional_properties: std::collections::HashMap<String, serde_json::Value>,
965}
966#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
967pub enum DeleteV1DomainsDomainRecordsTypeNameTypeEnum {
968 #[default]
969 #[serde(rename = "A")]
970 A,
971 #[serde(rename = "AAAA")]
972 Aaaa,
973 #[serde(rename = "CNAME")]
974 Cname,
975 #[serde(rename = "MX")]
976 Mx,
977 #[serde(rename = "SRV")]
978 Srv,
979 #[serde(rename = "TXT")]
980 Txt,
981}
982impl std::fmt::Display for DeleteV1DomainsDomainRecordsTypeNameTypeEnum {
983 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
984 let str_val = match self {
985 DeleteV1DomainsDomainRecordsTypeNameTypeEnum::A => "A",
986 DeleteV1DomainsDomainRecordsTypeNameTypeEnum::Aaaa => "AAAA",
987 DeleteV1DomainsDomainRecordsTypeNameTypeEnum::Cname => "CNAME",
988 DeleteV1DomainsDomainRecordsTypeNameTypeEnum::Mx => "MX",
989 DeleteV1DomainsDomainRecordsTypeNameTypeEnum::Srv => "SRV",
990 DeleteV1DomainsDomainRecordsTypeNameTypeEnum::Txt => "TXT",
991 };
992 write!(f, "{}", str_val)
993 }
994}
995#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
996pub enum DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum {
997 #[default]
998 #[serde(rename = "AUTH_CODE_PURCHASE")]
999 AuthCodePurchase,
1000 #[serde(rename = "AUTH_CODE_REGENERATE")]
1001 AuthCodeRegenerate,
1002 #[serde(rename = "BACKORDER_PURCHASE")]
1003 BackorderPurchase,
1004 #[serde(rename = "BACKORDER_DELETE")]
1005 BackorderDelete,
1006 #[serde(rename = "BACKORDER_UPDATE")]
1007 BackorderUpdate,
1008 #[serde(rename = "CHANGE_OF_REGISTRANT_DELETE")]
1009 ChangeOfRegistrantDelete,
1010 #[serde(rename = "DNSSEC_CREATE")]
1011 DnssecCreate,
1012 #[serde(rename = "DNSSEC_DELETE")]
1013 DnssecDelete,
1014 #[serde(rename = "DOMAIN_DELETE")]
1015 DomainDelete,
1016 #[serde(rename = "DOMAIN_UPDATE")]
1017 DomainUpdate,
1018 #[serde(rename = "DOMAIN_UPDATE_CONTACTS")]
1019 DomainUpdateContacts,
1020 #[serde(rename = "DOMAIN_UPDATE_NAME_SERVERS")]
1021 DomainUpdateNameServers,
1022 #[serde(rename = "MIGRATE")]
1023 Migrate,
1024 #[serde(rename = "PRIVACY_FORWARDING_UPDATE")]
1025 PrivacyForwardingUpdate,
1026 #[serde(rename = "PRIVACY_PURCHASE")]
1027 PrivacyPurchase,
1028 #[serde(rename = "PRIVACY_DELETE")]
1029 PrivacyDelete,
1030 #[serde(rename = "REDEEM")]
1031 Redeem,
1032 #[serde(rename = "REGISTER")]
1033 Register,
1034 #[serde(rename = "RENEW")]
1035 Renew,
1036 #[serde(rename = "RENEW_UNDO")]
1037 RenewUndo,
1038 #[serde(rename = "TRADE")]
1039 Trade,
1040 #[serde(rename = "TRADE_CANCEL")]
1041 TradeCancel,
1042 #[serde(rename = "TRADE_PURCHASE")]
1043 TradePurchase,
1044 #[serde(rename = "TRADE_PURCHASE_AUTH_TEXT_MESSAGE")]
1045 TradePurchaseAuthTextMessage,
1046 #[serde(rename = "TRADE_RESEND_AUTH_EMAIL")]
1047 TradeResendAuthEmail,
1048 #[serde(rename = "TRANSFER")]
1049 Transfer,
1050 #[serde(rename = "TRANSFER_IN_ACCEPT")]
1051 TransferInAccept,
1052 #[serde(rename = "TRANSFER_IN_CANCEL")]
1053 TransferInCancel,
1054 #[serde(rename = "TRANSFER_IN_RESTART")]
1055 TransferInRestart,
1056 #[serde(rename = "TRANSFER_IN_RETRY")]
1057 TransferInRetry,
1058 #[serde(rename = "TRANSFER_OUT_ACCEPT")]
1059 TransferOutAccept,
1060 #[serde(rename = "TRANSFER_OUT_REJECT")]
1061 TransferOutReject,
1062 #[serde(rename = "TRANSFER_OUT_REQUESTED")]
1063 TransferOutRequested,
1064 #[serde(rename = "TRANSIT")]
1065 Transit,
1066}
1067impl std::fmt::Display for DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum {
1068 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1069 let str_val = match self {
1070 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AuthCodePurchase => {
1071 "AUTH_CODE_PURCHASE"
1072 }
1073 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AuthCodeRegenerate => {
1074 "AUTH_CODE_REGENERATE"
1075 }
1076 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::BackorderPurchase => {
1077 "BACKORDER_PURCHASE"
1078 }
1079 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::BackorderDelete => {
1080 "BACKORDER_DELETE"
1081 }
1082 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::BackorderUpdate => {
1083 "BACKORDER_UPDATE"
1084 }
1085 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::ChangeOfRegistrantDelete => {
1086 "CHANGE_OF_REGISTRANT_DELETE"
1087 }
1088 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DnssecCreate => {
1089 "DNSSEC_CREATE"
1090 }
1091 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DnssecDelete => {
1092 "DNSSEC_DELETE"
1093 }
1094 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainDelete => {
1095 "DOMAIN_DELETE"
1096 }
1097 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainUpdate => {
1098 "DOMAIN_UPDATE"
1099 }
1100 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainUpdateContacts => {
1101 "DOMAIN_UPDATE_CONTACTS"
1102 }
1103 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainUpdateNameServers => {
1104 "DOMAIN_UPDATE_NAME_SERVERS"
1105 }
1106 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Migrate => {
1107 "MIGRATE"
1108 }
1109 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::PrivacyForwardingUpdate => {
1110 "PRIVACY_FORWARDING_UPDATE"
1111 }
1112 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::PrivacyPurchase => {
1113 "PRIVACY_PURCHASE"
1114 }
1115 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::PrivacyDelete => {
1116 "PRIVACY_DELETE"
1117 }
1118 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Redeem => {
1119 "REDEEM"
1120 }
1121 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Register => {
1122 "REGISTER"
1123 }
1124 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Renew => "RENEW",
1125 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::RenewUndo => {
1126 "RENEW_UNDO"
1127 }
1128 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Trade => "TRADE",
1129 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradeCancel => {
1130 "TRADE_CANCEL"
1131 }
1132 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradePurchase => {
1133 "TRADE_PURCHASE"
1134 }
1135 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradePurchaseAuthTextMessage => {
1136 "TRADE_PURCHASE_AUTH_TEXT_MESSAGE"
1137 }
1138 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradeResendAuthEmail => {
1139 "TRADE_RESEND_AUTH_EMAIL"
1140 }
1141 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Transfer => {
1142 "TRANSFER"
1143 }
1144 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInAccept => {
1145 "TRANSFER_IN_ACCEPT"
1146 }
1147 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInCancel => {
1148 "TRANSFER_IN_CANCEL"
1149 }
1150 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInRestart => {
1151 "TRANSFER_IN_RESTART"
1152 }
1153 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInRetry => {
1154 "TRANSFER_IN_RETRY"
1155 }
1156 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOutAccept => {
1157 "TRANSFER_OUT_ACCEPT"
1158 }
1159 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOutReject => {
1160 "TRANSFER_OUT_REJECT"
1161 }
1162 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOutRequested => {
1163 "TRANSFER_OUT_REQUESTED"
1164 }
1165 DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Transit => {
1166 "TRANSIT"
1167 }
1168 };
1169 write!(f, "{}", str_val)
1170 }
1171}
1172#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
1173pub enum GetV1DomainsIncludesItemEnum {
1174 #[default]
1175 #[serde(rename = "authCode")]
1176 AuthCode,
1177 #[serde(rename = "contacts")]
1178 Contacts,
1179 #[serde(rename = "nameServers")]
1180 NameServers,
1181}
1182impl std::fmt::Display for GetV1DomainsIncludesItemEnum {
1183 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1184 let str_val = match self {
1185 GetV1DomainsIncludesItemEnum::AuthCode => "authCode",
1186 GetV1DomainsIncludesItemEnum::Contacts => "contacts",
1187 GetV1DomainsIncludesItemEnum::NameServers => "nameServers",
1188 };
1189 write!(f, "{}", str_val)
1190 }
1191}
1192#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
1193pub enum GetV1DomainsStatusGroupsItemEnum {
1194 #[default]
1195 #[serde(rename = "INACTIVE")]
1196 Inactive,
1197 #[serde(rename = "PRE_REGISTRATION")]
1198 PreRegistration,
1199 #[serde(rename = "REDEMPTION")]
1200 Redemption,
1201 #[serde(rename = "RENEWABLE")]
1202 Renewable,
1203 #[serde(rename = "VERIFICATION_ICANN")]
1204 VerificationIcann,
1205 #[serde(rename = "VISIBLE")]
1206 Visible,
1207}
1208impl std::fmt::Display for GetV1DomainsStatusGroupsItemEnum {
1209 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1210 let str_val = match self {
1211 GetV1DomainsStatusGroupsItemEnum::Inactive => "INACTIVE",
1212 GetV1DomainsStatusGroupsItemEnum::PreRegistration => "PRE_REGISTRATION",
1213 GetV1DomainsStatusGroupsItemEnum::Redemption => "REDEMPTION",
1214 GetV1DomainsStatusGroupsItemEnum::Renewable => "RENEWABLE",
1215 GetV1DomainsStatusGroupsItemEnum::VerificationIcann => "VERIFICATION_ICANN",
1216 GetV1DomainsStatusGroupsItemEnum::Visible => "VISIBLE",
1217 };
1218 write!(f, "{}", str_val)
1219 }
1220}
1221#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
1222pub enum GetV1DomainsStatusesItemEnum {
1223 #[default]
1224 #[serde(rename = "ACTIVE")]
1225 Active,
1226 #[serde(rename = "AWAITING_CLAIM_ACK")]
1227 AwaitingClaimAck,
1228 #[serde(rename = "AWAITING_DOCUMENT_AFTER_TRANSFER")]
1229 AwaitingDocumentAfterTransfer,
1230 #[serde(rename = "AWAITING_DOCUMENT_AFTER_UPDATE_ACCOUNT")]
1231 AwaitingDocumentAfterUpdateAccount,
1232 #[serde(rename = "AWAITING_DOCUMENT_UPLOAD")]
1233 AwaitingDocumentUpload,
1234 #[serde(rename = "AWAITING_FAILED_TRANSFER_WHOIS_PRIVACY")]
1235 AwaitingFailedTransferWhoisPrivacy,
1236 #[serde(rename = "AWAITING_PAYMENT")]
1237 AwaitingPayment,
1238 #[serde(rename = "AWAITING_RENEWAL_TRANSFER_IN_COMPLETE")]
1239 AwaitingRenewalTransferInComplete,
1240 #[serde(rename = "AWAITING_TRANSFER_IN_ACK")]
1241 AwaitingTransferInAck,
1242 #[serde(rename = "AWAITING_TRANSFER_IN_AUTH")]
1243 AwaitingTransferInAuth,
1244 #[serde(rename = "AWAITING_TRANSFER_IN_AUTO")]
1245 AwaitingTransferInAuto,
1246 #[serde(rename = "AWAITING_TRANSFER_IN_WHOIS")]
1247 AwaitingTransferInWhois,
1248 #[serde(rename = "AWAITING_TRANSFER_IN_WHOIS_FIX")]
1249 AwaitingTransferInWhoisFix,
1250 #[serde(rename = "AWAITING_VERIFICATION_ICANN")]
1251 AwaitingVerificationIcann,
1252 #[serde(rename = "AWAITING_VERIFICATION_ICANN_MANUAL")]
1253 AwaitingVerificationIcannManual,
1254 #[serde(rename = "CANCELLED")]
1255 Cancelled,
1256 #[serde(rename = "CANCELLED_HELD")]
1257 CancelledHeld,
1258 #[serde(rename = "CANCELLED_REDEEMABLE")]
1259 CancelledRedeemable,
1260 #[serde(rename = "CANCELLED_TRANSFER")]
1261 CancelledTransfer,
1262 #[serde(rename = "CONFISCATED")]
1263 Confiscated,
1264 #[serde(rename = "DISABLED_SPECIAL")]
1265 DisabledSpecial,
1266 #[serde(rename = "EXCLUDED_INVALID_CLAIM_FIREHOSE")]
1267 ExcludedInvalidClaimFirehose,
1268 #[serde(rename = "EXPIRED_REASSIGNED")]
1269 ExpiredReassigned,
1270 #[serde(rename = "FAILED_BACKORDER_CAPTURE")]
1271 FailedBackorderCapture,
1272 #[serde(rename = "FAILED_DROP_IMMEDIATE_THEN_ADD")]
1273 FailedDropImmediateThenAdd,
1274 #[serde(rename = "FAILED_PRE_REGISTRATION")]
1275 FailedPreRegistration,
1276 #[serde(rename = "FAILED_REDEMPTION")]
1277 FailedRedemption,
1278 #[serde(rename = "FAILED_REDEMPTION_REPORT")]
1279 FailedRedemptionReport,
1280 #[serde(rename = "FAILED_REGISTRATION")]
1281 FailedRegistration,
1282 #[serde(rename = "FAILED_REGISTRATION_FIREHOSE")]
1283 FailedRegistrationFirehose,
1284 #[serde(rename = "FAILED_RESTORATION_REDEMPTION_MOCK")]
1285 FailedRestorationRedemptionMock,
1286 #[serde(rename = "FAILED_SETUP")]
1287 FailedSetup,
1288 #[serde(rename = "FAILED_TRANSFER_IN")]
1289 FailedTransferIn,
1290 #[serde(rename = "FAILED_TRANSFER_IN_BAD_STATUS")]
1291 FailedTransferInBadStatus,
1292 #[serde(rename = "FAILED_TRANSFER_IN_REGISTRY")]
1293 FailedTransferInRegistry,
1294 #[serde(rename = "HELD_COURT_ORDERED")]
1295 HeldCourtOrdered,
1296 #[serde(rename = "HELD_DISPUTED")]
1297 HeldDisputed,
1298 #[serde(rename = "HELD_EXPIRATION_PROTECTION")]
1299 HeldExpirationProtection,
1300 #[serde(rename = "HELD_EXPIRED_REDEMPTION_MOCK")]
1301 HeldExpiredRedemptionMock,
1302 #[serde(rename = "HELD_REGISTRAR_ADD")]
1303 HeldRegistrarAdd,
1304 #[serde(rename = "HELD_REGISTRAR_REMOVE")]
1305 HeldRegistrarRemove,
1306 #[serde(rename = "HELD_SHOPPER")]
1307 HeldShopper,
1308 #[serde(rename = "HELD_TEMPORARY")]
1309 HeldTemporary,
1310 #[serde(rename = "LOCKED_ABUSE")]
1311 LockedAbuse,
1312 #[serde(rename = "LOCKED_COPYRIGHT")]
1313 LockedCopyright,
1314 #[serde(rename = "LOCKED_REGISTRY")]
1315 LockedRegistry,
1316 #[serde(rename = "LOCKED_SUPER")]
1317 LockedSuper,
1318 #[serde(rename = "PARKED_AND_HELD")]
1319 ParkedAndHeld,
1320 #[serde(rename = "PARKED_EXPIRED")]
1321 ParkedExpired,
1322 #[serde(rename = "PARKED_VERIFICATION_ICANN")]
1323 ParkedVerificationIcann,
1324 #[serde(rename = "PENDING_ABORT_CANCEL_SETUP")]
1325 PendingAbortCancelSetup,
1326 #[serde(rename = "PENDING_AGREEMENT_PRE_REGISTRATION")]
1327 PendingAgreementPreRegistration,
1328 #[serde(rename = "PENDING_APPLY_RENEWAL_CREDITS")]
1329 PendingApplyRenewalCredits,
1330 #[serde(rename = "PENDING_BACKORDER_CAPTURE")]
1331 PendingBackorderCapture,
1332 #[serde(rename = "PENDING_BLOCKED_REGISTRY")]
1333 PendingBlockedRegistry,
1334 #[serde(rename = "PENDING_CANCEL_REGISTRANT_PROFILE")]
1335 PendingCancelRegistrantProfile,
1336 #[serde(rename = "PENDING_COMPLETE_REDEMPTION_WITHOUT_RECEIPT")]
1337 PendingCompleteRedemptionWithoutReceipt,
1338 #[serde(rename = "PENDING_COMPLETE_REGISTRANT_PROFILE")]
1339 PendingCompleteRegistrantProfile,
1340 #[serde(rename = "PENDING_COO")]
1341 PendingCoo,
1342 #[serde(rename = "PENDING_COO_COMPLETE")]
1343 PendingCooComplete,
1344 #[serde(rename = "PENDING_DNS")]
1345 PendingDns,
1346 #[serde(rename = "PENDING_DNS_ACTIVE")]
1347 PendingDnsActive,
1348 #[serde(rename = "PENDING_DNS_INACTIVE")]
1349 PendingDnsInactive,
1350 #[serde(rename = "PENDING_DOCUMENT_VALIDATION")]
1351 PendingDocumentValidation,
1352 #[serde(rename = "PENDING_DOCUMENT_VERIFICATION")]
1353 PendingDocumentVerification,
1354 #[serde(rename = "PENDING_DROP_IMMEDIATE")]
1355 PendingDropImmediate,
1356 #[serde(rename = "PENDING_DROP_IMMEDIATE_THEN_ADD")]
1357 PendingDropImmediateThenAdd,
1358 #[serde(rename = "PENDING_EPP_CREATE")]
1359 PendingEppCreate,
1360 #[serde(rename = "PENDING_EPP_DELETE")]
1361 PendingEppDelete,
1362 #[serde(rename = "PENDING_EPP_UPDATE")]
1363 PendingEppUpdate,
1364 #[serde(rename = "PENDING_ESCALATION_REGISTRY")]
1365 PendingEscalationRegistry,
1366 #[serde(rename = "PENDING_EXPIRATION")]
1367 PendingExpiration,
1368 #[serde(rename = "PENDING_EXPIRATION_RESPONSE")]
1369 PendingExpirationResponse,
1370 #[serde(rename = "PENDING_EXPIRATION_SYNC")]
1371 PendingExpirationSync,
1372 #[serde(rename = "PENDING_EXPIRED_REASSIGNMENT")]
1373 PendingExpiredReassignment,
1374 #[serde(rename = "PENDING_EXPIRE_AUTO_ADD")]
1375 PendingExpireAutoAdd,
1376 #[serde(rename = "PENDING_EXTEND_REGISTRANT_PROFILE")]
1377 PendingExtendRegistrantProfile,
1378 #[serde(rename = "PENDING_FAILED_COO")]
1379 PendingFailedCoo,
1380 #[serde(rename = "PENDING_FAILED_EPP_CREATE")]
1381 PendingFailedEppCreate,
1382 #[serde(rename = "PENDING_FAILED_HELD")]
1383 PendingFailedHeld,
1384 #[serde(rename = "PENDING_FAILED_PURCHASE_PREMIUM")]
1385 PendingFailedPurchasePremium,
1386 #[serde(rename = "PENDING_FAILED_RECONCILE_FIREHOSE")]
1387 PendingFailedReconcileFirehose,
1388 #[serde(rename = "PENDING_FAILED_REDEMPTION_WITHOUT_RECEIPT")]
1389 PendingFailedRedemptionWithoutReceipt,
1390 #[serde(rename = "PENDING_FAILED_RELEASE_PREMIUM")]
1391 PendingFailedReleasePremium,
1392 #[serde(rename = "PENDING_FAILED_RENEW_EXPIRATION_PROTECTION")]
1393 PendingFailedRenewExpirationProtection,
1394 #[serde(rename = "PENDING_FAILED_RESERVE_PREMIUM")]
1395 PendingFailedReservePremium,
1396 #[serde(rename = "PENDING_FAILED_SUBMIT_FIREHOSE")]
1397 PendingFailedSubmitFirehose,
1398 #[serde(rename = "PENDING_FAILED_TRANSFER_ACK_PREMIUM")]
1399 PendingFailedTransferAckPremium,
1400 #[serde(rename = "PENDING_FAILED_TRANSFER_IN_ACK_PREMIUM")]
1401 PendingFailedTransferInAckPremium,
1402 #[serde(rename = "PENDING_FAILED_TRANSFER_IN_PREMIUM")]
1403 PendingFailedTransferInPremium,
1404 #[serde(rename = "PENDING_FAILED_TRANSFER_PREMIUM")]
1405 PendingFailedTransferPremium,
1406 #[serde(rename = "PENDING_FAILED_TRANSFER_SUBMIT_PREMIUM")]
1407 PendingFailedTransferSubmitPremium,
1408 #[serde(rename = "PENDING_FAILED_UNLOCK_PREMIUM")]
1409 PendingFailedUnlockPremium,
1410 #[serde(rename = "PENDING_FAILED_UPDATE_API")]
1411 PendingFailedUpdateApi,
1412 #[serde(rename = "PENDING_FRAUD_VERIFICATION")]
1413 PendingFraudVerification,
1414 #[serde(rename = "PENDING_FRAUD_VERIFIED")]
1415 PendingFraudVerified,
1416 #[serde(rename = "PENDING_GET_CONTACTS")]
1417 PendingGetContacts,
1418 #[serde(rename = "PENDING_GET_HOSTS")]
1419 PendingGetHosts,
1420 #[serde(rename = "PENDING_GET_NAME_SERVERS")]
1421 PendingGetNameServers,
1422 #[serde(rename = "PENDING_GET_STATUS")]
1423 PendingGetStatus,
1424 #[serde(rename = "PENDING_HOLD_ESCROW")]
1425 PendingHoldEscrow,
1426 #[serde(rename = "PENDING_HOLD_REDEMPTION")]
1427 PendingHoldRedemption,
1428 #[serde(rename = "PENDING_LOCK_CLIENT_REMOVE")]
1429 PendingLockClientRemove,
1430 #[serde(rename = "PENDING_LOCK_DATA_QUALITY")]
1431 PendingLockDataQuality,
1432 #[serde(rename = "PENDING_LOCK_THEN_HOLD_REDEMPTION")]
1433 PendingLockThenHoldRedemption,
1434 #[serde(rename = "PENDING_PARKING_DETERMINATION")]
1435 PendingParkingDetermination,
1436 #[serde(rename = "PENDING_PARK_INVALID_WHOIS")]
1437 PendingParkInvalidWhois,
1438 #[serde(rename = "PENDING_PARK_INVALID_WHOIS_REMOVAL")]
1439 PendingParkInvalidWhoisRemoval,
1440 #[serde(rename = "PENDING_PURCHASE_PREMIUM")]
1441 PendingPurchasePremium,
1442 #[serde(rename = "PENDING_RECONCILE")]
1443 PendingReconcile,
1444 #[serde(rename = "PENDING_RECONCILE_FIREHOSE")]
1445 PendingReconcileFirehose,
1446 #[serde(rename = "PENDING_REDEMPTION")]
1447 PendingRedemption,
1448 #[serde(rename = "PENDING_REDEMPTION_REPORT")]
1449 PendingRedemptionReport,
1450 #[serde(rename = "PENDING_REDEMPTION_REPORT_COMPLETE")]
1451 PendingRedemptionReportComplete,
1452 #[serde(rename = "PENDING_REDEMPTION_REPORT_SUBMITTED")]
1453 PendingRedemptionReportSubmitted,
1454 #[serde(rename = "PENDING_REDEMPTION_WITHOUT_RECEIPT")]
1455 PendingRedemptionWithoutReceipt,
1456 #[serde(rename = "PENDING_REDEMPTION_WITHOUT_RECEIPT_MOCK")]
1457 PendingRedemptionWithoutReceiptMock,
1458 #[serde(rename = "PENDING_RELEASE_PREMIUM")]
1459 PendingReleasePremium,
1460 #[serde(rename = "PENDING_REMOVAL")]
1461 PendingRemoval,
1462 #[serde(rename = "PENDING_REMOVAL_HELD")]
1463 PendingRemovalHeld,
1464 #[serde(rename = "PENDING_REMOVAL_PARKED")]
1465 PendingRemovalParked,
1466 #[serde(rename = "PENDING_REMOVAL_UNPARK")]
1467 PendingRemovalUnpark,
1468 #[serde(rename = "PENDING_RENEWAL")]
1469 PendingRenewal,
1470 #[serde(rename = "PENDING_RENEW_EXPIRATION_PROTECTION")]
1471 PendingRenewExpirationProtection,
1472 #[serde(rename = "PENDING_RENEW_INFINITE")]
1473 PendingRenewInfinite,
1474 #[serde(rename = "PENDING_RENEW_LOCKED")]
1475 PendingRenewLocked,
1476 #[serde(rename = "PENDING_RENEW_WITHOUT_RECEIPT")]
1477 PendingRenewWithoutReceipt,
1478 #[serde(rename = "PENDING_REPORT_REDEMPTION_WITHOUT_RECEIPT")]
1479 PendingReportRedemptionWithoutReceipt,
1480 #[serde(rename = "PENDING_RESERVE_PREMIUM")]
1481 PendingReservePremium,
1482 #[serde(rename = "PENDING_RESET_VERIFICATION_ICANN")]
1483 PendingResetVerificationIcann,
1484 #[serde(rename = "PENDING_RESPONSE_FIREHOSE")]
1485 PendingResponseFirehose,
1486 #[serde(rename = "PENDING_RESTORATION")]
1487 PendingRestoration,
1488 #[serde(rename = "PENDING_RESTORATION_INACTIVE")]
1489 PendingRestorationInactive,
1490 #[serde(rename = "PENDING_RESTORATION_REDEMPTION_MOCK")]
1491 PendingRestorationRedemptionMock,
1492 #[serde(rename = "PENDING_RETRY_EPP_CREATE")]
1493 PendingRetryEppCreate,
1494 #[serde(rename = "PENDING_RETRY_HELD")]
1495 PendingRetryHeld,
1496 #[serde(rename = "PENDING_SEND_AUTH_CODE")]
1497 PendingSendAuthCode,
1498 #[serde(rename = "PENDING_SETUP")]
1499 PendingSetup,
1500 #[serde(rename = "PENDING_SETUP_ABANDON")]
1501 PendingSetupAbandon,
1502 #[serde(rename = "PENDING_SETUP_AGREEMENT_LANDRUSH")]
1503 PendingSetupAgreementLandrush,
1504 #[serde(rename = "PENDING_SETUP_AGREEMENT_SUNRISE2_A")]
1505 PendingSetupAgreementSunrise2A,
1506 #[serde(rename = "PENDING_SETUP_AGREEMENT_SUNRISE2_B")]
1507 PendingSetupAgreementSunrise2B,
1508 #[serde(rename = "PENDING_SETUP_AGREEMENT_SUNRISE2_C")]
1509 PendingSetupAgreementSunrise2C,
1510 #[serde(rename = "PENDING_SETUP_AUTH")]
1511 PendingSetupAuth,
1512 #[serde(rename = "PENDING_SETUP_DNS")]
1513 PendingSetupDns,
1514 #[serde(rename = "PENDING_SETUP_FAILED")]
1515 PendingSetupFailed,
1516 #[serde(rename = "PENDING_SETUP_REVIEW")]
1517 PendingSetupReview,
1518 #[serde(rename = "PENDING_SETUP_SUNRISE")]
1519 PendingSetupSunrise,
1520 #[serde(rename = "PENDING_SETUP_SUNRISE_PRE")]
1521 PendingSetupSunrisePre,
1522 #[serde(rename = "PENDING_SETUP_SUNRISE_RESPONSE")]
1523 PendingSetupSunriseResponse,
1524 #[serde(rename = "PENDING_SUBMIT_FAILURE")]
1525 PendingSubmitFailure,
1526 #[serde(rename = "PENDING_SUBMIT_FIREHOSE")]
1527 PendingSubmitFirehose,
1528 #[serde(rename = "PENDING_SUBMIT_HOLD_FIREHOSE")]
1529 PendingSubmitHoldFirehose,
1530 #[serde(rename = "PENDING_SUBMIT_HOLD_LANDRUSH")]
1531 PendingSubmitHoldLandrush,
1532 #[serde(rename = "PENDING_SUBMIT_HOLD_SUNRISE")]
1533 PendingSubmitHoldSunrise,
1534 #[serde(rename = "PENDING_SUBMIT_LANDRUSH")]
1535 PendingSubmitLandrush,
1536 #[serde(rename = "PENDING_SUBMIT_RESPONSE_FIREHOSE")]
1537 PendingSubmitResponseFirehose,
1538 #[serde(rename = "PENDING_SUBMIT_RESPONSE_LANDRUSH")]
1539 PendingSubmitResponseLandrush,
1540 #[serde(rename = "PENDING_SUBMIT_RESPONSE_SUNRISE")]
1541 PendingSubmitResponseSunrise,
1542 #[serde(rename = "PENDING_SUBMIT_SUCCESS_FIREHOSE")]
1543 PendingSubmitSuccessFirehose,
1544 #[serde(rename = "PENDING_SUBMIT_SUCCESS_LANDRUSH")]
1545 PendingSubmitSuccessLandrush,
1546 #[serde(rename = "PENDING_SUBMIT_SUCCESS_SUNRISE")]
1547 PendingSubmitSuccessSunrise,
1548 #[serde(rename = "PENDING_SUBMIT_SUNRISE")]
1549 PendingSubmitSunrise,
1550 #[serde(rename = "PENDING_SUBMIT_WAITING_LANDRUSH")]
1551 PendingSubmitWaitingLandrush,
1552 #[serde(rename = "PENDING_SUCCESS_PRE_REGISTRATION")]
1553 PendingSuccessPreRegistration,
1554 #[serde(rename = "PENDING_SUSPENDED_DATA_QUALITY")]
1555 PendingSuspendedDataQuality,
1556 #[serde(rename = "PENDING_TRANSFER_ACK_PREMIUM")]
1557 PendingTransferAckPremium,
1558 #[serde(rename = "PENDING_TRANSFER_IN")]
1559 PendingTransferIn,
1560 #[serde(rename = "PENDING_TRANSFER_IN_ACK")]
1561 PendingTransferInAck,
1562 #[serde(rename = "PENDING_TRANSFER_IN_ACK_PREMIUM")]
1563 PendingTransferInAckPremium,
1564 #[serde(rename = "PENDING_TRANSFER_IN_BAD_REGISTRANT")]
1565 PendingTransferInBadRegistrant,
1566 #[serde(rename = "PENDING_TRANSFER_IN_CANCEL")]
1567 PendingTransferInCancel,
1568 #[serde(rename = "PENDING_TRANSFER_IN_CANCEL_REGISTRY")]
1569 PendingTransferInCancelRegistry,
1570 #[serde(rename = "PENDING_TRANSFER_IN_COMPLETE_ACK")]
1571 PendingTransferInCompleteAck,
1572 #[serde(rename = "PENDING_TRANSFER_IN_DELETE")]
1573 PendingTransferInDelete,
1574 #[serde(rename = "PENDING_TRANSFER_IN_LOCK")]
1575 PendingTransferInLock,
1576 #[serde(rename = "PENDING_TRANSFER_IN_NACK")]
1577 PendingTransferInNack,
1578 #[serde(rename = "PENDING_TRANSFER_IN_NOTIFICATION")]
1579 PendingTransferInNotification,
1580 #[serde(rename = "PENDING_TRANSFER_IN_PREMIUM")]
1581 PendingTransferInPremium,
1582 #[serde(rename = "PENDING_TRANSFER_IN_RELEASE")]
1583 PendingTransferInRelease,
1584 #[serde(rename = "PENDING_TRANSFER_IN_RESPONSE")]
1585 PendingTransferInResponse,
1586 #[serde(rename = "PENDING_TRANSFER_IN_UNDERAGE")]
1587 PendingTransferInUnderage,
1588 #[serde(rename = "PENDING_TRANSFER_OUT")]
1589 PendingTransferOut,
1590 #[serde(rename = "PENDING_TRANSFER_OUT_ACK")]
1591 PendingTransferOutAck,
1592 #[serde(rename = "PENDING_TRANSFER_OUT_NACK")]
1593 PendingTransferOutNack,
1594 #[serde(rename = "PENDING_TRANSFER_OUT_PREMIUM")]
1595 PendingTransferOutPremium,
1596 #[serde(rename = "PENDING_TRANSFER_OUT_UNDERAGE")]
1597 PendingTransferOutUnderage,
1598 #[serde(rename = "PENDING_TRANSFER_OUT_VALIDATION")]
1599 PendingTransferOutValidation,
1600 #[serde(rename = "PENDING_TRANSFER_PREMIUM")]
1601 PendingTransferPremium,
1602 #[serde(rename = "PENDING_TRANSFER_PREMUIM")]
1603 PendingTransferPremuim,
1604 #[serde(rename = "PENDING_TRANSFER_SUBMIT_PREMIUM")]
1605 PendingTransferSubmitPremium,
1606 #[serde(rename = "PENDING_UNLOCK_DATA_QUALITY")]
1607 PendingUnlockDataQuality,
1608 #[serde(rename = "PENDING_UNLOCK_PREMIUM")]
1609 PendingUnlockPremium,
1610 #[serde(rename = "PENDING_UPDATE")]
1611 PendingUpdate,
1612 #[serde(rename = "PENDING_UPDATED_REGISTRANT_DATA_QUALITY")]
1613 PendingUpdatedRegistrantDataQuality,
1614 #[serde(rename = "PENDING_UPDATE_ACCOUNT")]
1615 PendingUpdateAccount,
1616 #[serde(rename = "PENDING_UPDATE_API")]
1617 PendingUpdateApi,
1618 #[serde(rename = "PENDING_UPDATE_API_RESPONSE")]
1619 PendingUpdateApiResponse,
1620 #[serde(rename = "PENDING_UPDATE_AUTH")]
1621 PendingUpdateAuth,
1622 #[serde(rename = "PENDING_UPDATE_CONTACTS")]
1623 PendingUpdateContacts,
1624 #[serde(rename = "PENDING_UPDATE_CONTACTS_PRIVACY")]
1625 PendingUpdateContactsPrivacy,
1626 #[serde(rename = "PENDING_UPDATE_DNS")]
1627 PendingUpdateDns,
1628 #[serde(rename = "PENDING_UPDATE_DNS_SECURITY")]
1629 PendingUpdateDnsSecurity,
1630 #[serde(rename = "PENDING_UPDATE_ELIGIBILITY")]
1631 PendingUpdateEligibility,
1632 #[serde(rename = "PENDING_UPDATE_EPP_CONTACTS")]
1633 PendingUpdateEppContacts,
1634 #[serde(rename = "PENDING_UPDATE_MEMBERSHIP")]
1635 PendingUpdateMembership,
1636 #[serde(rename = "PENDING_UPDATE_OWNERSHIP")]
1637 PendingUpdateOwnership,
1638 #[serde(rename = "PENDING_UPDATE_OWNERSHIP_AUTH_AUCTION")]
1639 PendingUpdateOwnershipAuthAuction,
1640 #[serde(rename = "PENDING_UPDATE_OWNERSHIP_HELD")]
1641 PendingUpdateOwnershipHeld,
1642 #[serde(rename = "PENDING_UPDATE_REGISTRANT")]
1643 PendingUpdateRegistrant,
1644 #[serde(rename = "PENDING_UPDATE_REPO")]
1645 PendingUpdateRepo,
1646 #[serde(rename = "PENDING_VALIDATION_DATA_QUALITY")]
1647 PendingValidationDataQuality,
1648 #[serde(rename = "PENDING_VERIFICATION_FRAUD")]
1649 PendingVerificationFraud,
1650 #[serde(rename = "PENDING_VERIFICATION_STATUS")]
1651 PendingVerificationStatus,
1652 #[serde(rename = "PENDING_VERIFY_REGISTRANT_DATA_QUALITY")]
1653 PendingVerifyRegistrantDataQuality,
1654 #[serde(rename = "RESERVED")]
1655 Reserved,
1656 #[serde(rename = "RESERVED_PREMIUM")]
1657 ReservedPremium,
1658 #[serde(rename = "REVERTED")]
1659 Reverted,
1660 #[serde(rename = "SUSPENDED_VERIFICATION_ICANN")]
1661 SuspendedVerificationIcann,
1662 #[serde(rename = "TRANSFERRED_OUT")]
1663 TransferredOut,
1664 #[serde(rename = "UNLOCKED_ABUSE")]
1665 UnlockedAbuse,
1666 #[serde(rename = "UNLOCKED_SUPER")]
1667 UnlockedSuper,
1668 #[serde(rename = "UNPARKED_AND_UNHELD")]
1669 UnparkedAndUnheld,
1670 #[serde(rename = "UPDATED_OWNERSHIP")]
1671 UpdatedOwnership,
1672 #[serde(rename = "UPDATED_OWNERSHIP_HELD")]
1673 UpdatedOwnershipHeld,
1674}
1675impl std::fmt::Display for GetV1DomainsStatusesItemEnum {
1676 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1677 let str_val = match self {
1678 GetV1DomainsStatusesItemEnum::Active => "ACTIVE",
1679 GetV1DomainsStatusesItemEnum::AwaitingClaimAck => "AWAITING_CLAIM_ACK",
1680 GetV1DomainsStatusesItemEnum::AwaitingDocumentAfterTransfer => {
1681 "AWAITING_DOCUMENT_AFTER_TRANSFER"
1682 }
1683 GetV1DomainsStatusesItemEnum::AwaitingDocumentAfterUpdateAccount => {
1684 "AWAITING_DOCUMENT_AFTER_UPDATE_ACCOUNT"
1685 }
1686 GetV1DomainsStatusesItemEnum::AwaitingDocumentUpload => "AWAITING_DOCUMENT_UPLOAD",
1687 GetV1DomainsStatusesItemEnum::AwaitingFailedTransferWhoisPrivacy => {
1688 "AWAITING_FAILED_TRANSFER_WHOIS_PRIVACY"
1689 }
1690 GetV1DomainsStatusesItemEnum::AwaitingPayment => "AWAITING_PAYMENT",
1691 GetV1DomainsStatusesItemEnum::AwaitingRenewalTransferInComplete => {
1692 "AWAITING_RENEWAL_TRANSFER_IN_COMPLETE"
1693 }
1694 GetV1DomainsStatusesItemEnum::AwaitingTransferInAck => "AWAITING_TRANSFER_IN_ACK",
1695 GetV1DomainsStatusesItemEnum::AwaitingTransferInAuth => "AWAITING_TRANSFER_IN_AUTH",
1696 GetV1DomainsStatusesItemEnum::AwaitingTransferInAuto => "AWAITING_TRANSFER_IN_AUTO",
1697 GetV1DomainsStatusesItemEnum::AwaitingTransferInWhois => "AWAITING_TRANSFER_IN_WHOIS",
1698 GetV1DomainsStatusesItemEnum::AwaitingTransferInWhoisFix => {
1699 "AWAITING_TRANSFER_IN_WHOIS_FIX"
1700 }
1701 GetV1DomainsStatusesItemEnum::AwaitingVerificationIcann => {
1702 "AWAITING_VERIFICATION_ICANN"
1703 }
1704 GetV1DomainsStatusesItemEnum::AwaitingVerificationIcannManual => {
1705 "AWAITING_VERIFICATION_ICANN_MANUAL"
1706 }
1707 GetV1DomainsStatusesItemEnum::Cancelled => "CANCELLED",
1708 GetV1DomainsStatusesItemEnum::CancelledHeld => "CANCELLED_HELD",
1709 GetV1DomainsStatusesItemEnum::CancelledRedeemable => "CANCELLED_REDEEMABLE",
1710 GetV1DomainsStatusesItemEnum::CancelledTransfer => "CANCELLED_TRANSFER",
1711 GetV1DomainsStatusesItemEnum::Confiscated => "CONFISCATED",
1712 GetV1DomainsStatusesItemEnum::DisabledSpecial => "DISABLED_SPECIAL",
1713 GetV1DomainsStatusesItemEnum::ExcludedInvalidClaimFirehose => {
1714 "EXCLUDED_INVALID_CLAIM_FIREHOSE"
1715 }
1716 GetV1DomainsStatusesItemEnum::ExpiredReassigned => "EXPIRED_REASSIGNED",
1717 GetV1DomainsStatusesItemEnum::FailedBackorderCapture => "FAILED_BACKORDER_CAPTURE",
1718 GetV1DomainsStatusesItemEnum::FailedDropImmediateThenAdd => {
1719 "FAILED_DROP_IMMEDIATE_THEN_ADD"
1720 }
1721 GetV1DomainsStatusesItemEnum::FailedPreRegistration => "FAILED_PRE_REGISTRATION",
1722 GetV1DomainsStatusesItemEnum::FailedRedemption => "FAILED_REDEMPTION",
1723 GetV1DomainsStatusesItemEnum::FailedRedemptionReport => "FAILED_REDEMPTION_REPORT",
1724 GetV1DomainsStatusesItemEnum::FailedRegistration => "FAILED_REGISTRATION",
1725 GetV1DomainsStatusesItemEnum::FailedRegistrationFirehose => {
1726 "FAILED_REGISTRATION_FIREHOSE"
1727 }
1728 GetV1DomainsStatusesItemEnum::FailedRestorationRedemptionMock => {
1729 "FAILED_RESTORATION_REDEMPTION_MOCK"
1730 }
1731 GetV1DomainsStatusesItemEnum::FailedSetup => "FAILED_SETUP",
1732 GetV1DomainsStatusesItemEnum::FailedTransferIn => "FAILED_TRANSFER_IN",
1733 GetV1DomainsStatusesItemEnum::FailedTransferInBadStatus => {
1734 "FAILED_TRANSFER_IN_BAD_STATUS"
1735 }
1736 GetV1DomainsStatusesItemEnum::FailedTransferInRegistry => "FAILED_TRANSFER_IN_REGISTRY",
1737 GetV1DomainsStatusesItemEnum::HeldCourtOrdered => "HELD_COURT_ORDERED",
1738 GetV1DomainsStatusesItemEnum::HeldDisputed => "HELD_DISPUTED",
1739 GetV1DomainsStatusesItemEnum::HeldExpirationProtection => "HELD_EXPIRATION_PROTECTION",
1740 GetV1DomainsStatusesItemEnum::HeldExpiredRedemptionMock => {
1741 "HELD_EXPIRED_REDEMPTION_MOCK"
1742 }
1743 GetV1DomainsStatusesItemEnum::HeldRegistrarAdd => "HELD_REGISTRAR_ADD",
1744 GetV1DomainsStatusesItemEnum::HeldRegistrarRemove => "HELD_REGISTRAR_REMOVE",
1745 GetV1DomainsStatusesItemEnum::HeldShopper => "HELD_SHOPPER",
1746 GetV1DomainsStatusesItemEnum::HeldTemporary => "HELD_TEMPORARY",
1747 GetV1DomainsStatusesItemEnum::LockedAbuse => "LOCKED_ABUSE",
1748 GetV1DomainsStatusesItemEnum::LockedCopyright => "LOCKED_COPYRIGHT",
1749 GetV1DomainsStatusesItemEnum::LockedRegistry => "LOCKED_REGISTRY",
1750 GetV1DomainsStatusesItemEnum::LockedSuper => "LOCKED_SUPER",
1751 GetV1DomainsStatusesItemEnum::ParkedAndHeld => "PARKED_AND_HELD",
1752 GetV1DomainsStatusesItemEnum::ParkedExpired => "PARKED_EXPIRED",
1753 GetV1DomainsStatusesItemEnum::ParkedVerificationIcann => "PARKED_VERIFICATION_ICANN",
1754 GetV1DomainsStatusesItemEnum::PendingAbortCancelSetup => "PENDING_ABORT_CANCEL_SETUP",
1755 GetV1DomainsStatusesItemEnum::PendingAgreementPreRegistration => {
1756 "PENDING_AGREEMENT_PRE_REGISTRATION"
1757 }
1758 GetV1DomainsStatusesItemEnum::PendingApplyRenewalCredits => {
1759 "PENDING_APPLY_RENEWAL_CREDITS"
1760 }
1761 GetV1DomainsStatusesItemEnum::PendingBackorderCapture => "PENDING_BACKORDER_CAPTURE",
1762 GetV1DomainsStatusesItemEnum::PendingBlockedRegistry => "PENDING_BLOCKED_REGISTRY",
1763 GetV1DomainsStatusesItemEnum::PendingCancelRegistrantProfile => {
1764 "PENDING_CANCEL_REGISTRANT_PROFILE"
1765 }
1766 GetV1DomainsStatusesItemEnum::PendingCompleteRedemptionWithoutReceipt => {
1767 "PENDING_COMPLETE_REDEMPTION_WITHOUT_RECEIPT"
1768 }
1769 GetV1DomainsStatusesItemEnum::PendingCompleteRegistrantProfile => {
1770 "PENDING_COMPLETE_REGISTRANT_PROFILE"
1771 }
1772 GetV1DomainsStatusesItemEnum::PendingCoo => "PENDING_COO",
1773 GetV1DomainsStatusesItemEnum::PendingCooComplete => "PENDING_COO_COMPLETE",
1774 GetV1DomainsStatusesItemEnum::PendingDns => "PENDING_DNS",
1775 GetV1DomainsStatusesItemEnum::PendingDnsActive => "PENDING_DNS_ACTIVE",
1776 GetV1DomainsStatusesItemEnum::PendingDnsInactive => "PENDING_DNS_INACTIVE",
1777 GetV1DomainsStatusesItemEnum::PendingDocumentValidation => {
1778 "PENDING_DOCUMENT_VALIDATION"
1779 }
1780 GetV1DomainsStatusesItemEnum::PendingDocumentVerification => {
1781 "PENDING_DOCUMENT_VERIFICATION"
1782 }
1783 GetV1DomainsStatusesItemEnum::PendingDropImmediate => "PENDING_DROP_IMMEDIATE",
1784 GetV1DomainsStatusesItemEnum::PendingDropImmediateThenAdd => {
1785 "PENDING_DROP_IMMEDIATE_THEN_ADD"
1786 }
1787 GetV1DomainsStatusesItemEnum::PendingEppCreate => "PENDING_EPP_CREATE",
1788 GetV1DomainsStatusesItemEnum::PendingEppDelete => "PENDING_EPP_DELETE",
1789 GetV1DomainsStatusesItemEnum::PendingEppUpdate => "PENDING_EPP_UPDATE",
1790 GetV1DomainsStatusesItemEnum::PendingEscalationRegistry => {
1791 "PENDING_ESCALATION_REGISTRY"
1792 }
1793 GetV1DomainsStatusesItemEnum::PendingExpiration => "PENDING_EXPIRATION",
1794 GetV1DomainsStatusesItemEnum::PendingExpirationResponse => {
1795 "PENDING_EXPIRATION_RESPONSE"
1796 }
1797 GetV1DomainsStatusesItemEnum::PendingExpirationSync => "PENDING_EXPIRATION_SYNC",
1798 GetV1DomainsStatusesItemEnum::PendingExpiredReassignment => {
1799 "PENDING_EXPIRED_REASSIGNMENT"
1800 }
1801 GetV1DomainsStatusesItemEnum::PendingExpireAutoAdd => "PENDING_EXPIRE_AUTO_ADD",
1802 GetV1DomainsStatusesItemEnum::PendingExtendRegistrantProfile => {
1803 "PENDING_EXTEND_REGISTRANT_PROFILE"
1804 }
1805 GetV1DomainsStatusesItemEnum::PendingFailedCoo => "PENDING_FAILED_COO",
1806 GetV1DomainsStatusesItemEnum::PendingFailedEppCreate => "PENDING_FAILED_EPP_CREATE",
1807 GetV1DomainsStatusesItemEnum::PendingFailedHeld => "PENDING_FAILED_HELD",
1808 GetV1DomainsStatusesItemEnum::PendingFailedPurchasePremium => {
1809 "PENDING_FAILED_PURCHASE_PREMIUM"
1810 }
1811 GetV1DomainsStatusesItemEnum::PendingFailedReconcileFirehose => {
1812 "PENDING_FAILED_RECONCILE_FIREHOSE"
1813 }
1814 GetV1DomainsStatusesItemEnum::PendingFailedRedemptionWithoutReceipt => {
1815 "PENDING_FAILED_REDEMPTION_WITHOUT_RECEIPT"
1816 }
1817 GetV1DomainsStatusesItemEnum::PendingFailedReleasePremium => {
1818 "PENDING_FAILED_RELEASE_PREMIUM"
1819 }
1820 GetV1DomainsStatusesItemEnum::PendingFailedRenewExpirationProtection => {
1821 "PENDING_FAILED_RENEW_EXPIRATION_PROTECTION"
1822 }
1823 GetV1DomainsStatusesItemEnum::PendingFailedReservePremium => {
1824 "PENDING_FAILED_RESERVE_PREMIUM"
1825 }
1826 GetV1DomainsStatusesItemEnum::PendingFailedSubmitFirehose => {
1827 "PENDING_FAILED_SUBMIT_FIREHOSE"
1828 }
1829 GetV1DomainsStatusesItemEnum::PendingFailedTransferAckPremium => {
1830 "PENDING_FAILED_TRANSFER_ACK_PREMIUM"
1831 }
1832 GetV1DomainsStatusesItemEnum::PendingFailedTransferInAckPremium => {
1833 "PENDING_FAILED_TRANSFER_IN_ACK_PREMIUM"
1834 }
1835 GetV1DomainsStatusesItemEnum::PendingFailedTransferInPremium => {
1836 "PENDING_FAILED_TRANSFER_IN_PREMIUM"
1837 }
1838 GetV1DomainsStatusesItemEnum::PendingFailedTransferPremium => {
1839 "PENDING_FAILED_TRANSFER_PREMIUM"
1840 }
1841 GetV1DomainsStatusesItemEnum::PendingFailedTransferSubmitPremium => {
1842 "PENDING_FAILED_TRANSFER_SUBMIT_PREMIUM"
1843 }
1844 GetV1DomainsStatusesItemEnum::PendingFailedUnlockPremium => {
1845 "PENDING_FAILED_UNLOCK_PREMIUM"
1846 }
1847 GetV1DomainsStatusesItemEnum::PendingFailedUpdateApi => "PENDING_FAILED_UPDATE_API",
1848 GetV1DomainsStatusesItemEnum::PendingFraudVerification => "PENDING_FRAUD_VERIFICATION",
1849 GetV1DomainsStatusesItemEnum::PendingFraudVerified => "PENDING_FRAUD_VERIFIED",
1850 GetV1DomainsStatusesItemEnum::PendingGetContacts => "PENDING_GET_CONTACTS",
1851 GetV1DomainsStatusesItemEnum::PendingGetHosts => "PENDING_GET_HOSTS",
1852 GetV1DomainsStatusesItemEnum::PendingGetNameServers => "PENDING_GET_NAME_SERVERS",
1853 GetV1DomainsStatusesItemEnum::PendingGetStatus => "PENDING_GET_STATUS",
1854 GetV1DomainsStatusesItemEnum::PendingHoldEscrow => "PENDING_HOLD_ESCROW",
1855 GetV1DomainsStatusesItemEnum::PendingHoldRedemption => "PENDING_HOLD_REDEMPTION",
1856 GetV1DomainsStatusesItemEnum::PendingLockClientRemove => "PENDING_LOCK_CLIENT_REMOVE",
1857 GetV1DomainsStatusesItemEnum::PendingLockDataQuality => "PENDING_LOCK_DATA_QUALITY",
1858 GetV1DomainsStatusesItemEnum::PendingLockThenHoldRedemption => {
1859 "PENDING_LOCK_THEN_HOLD_REDEMPTION"
1860 }
1861 GetV1DomainsStatusesItemEnum::PendingParkingDetermination => {
1862 "PENDING_PARKING_DETERMINATION"
1863 }
1864 GetV1DomainsStatusesItemEnum::PendingParkInvalidWhois => "PENDING_PARK_INVALID_WHOIS",
1865 GetV1DomainsStatusesItemEnum::PendingParkInvalidWhoisRemoval => {
1866 "PENDING_PARK_INVALID_WHOIS_REMOVAL"
1867 }
1868 GetV1DomainsStatusesItemEnum::PendingPurchasePremium => "PENDING_PURCHASE_PREMIUM",
1869 GetV1DomainsStatusesItemEnum::PendingReconcile => "PENDING_RECONCILE",
1870 GetV1DomainsStatusesItemEnum::PendingReconcileFirehose => "PENDING_RECONCILE_FIREHOSE",
1871 GetV1DomainsStatusesItemEnum::PendingRedemption => "PENDING_REDEMPTION",
1872 GetV1DomainsStatusesItemEnum::PendingRedemptionReport => "PENDING_REDEMPTION_REPORT",
1873 GetV1DomainsStatusesItemEnum::PendingRedemptionReportComplete => {
1874 "PENDING_REDEMPTION_REPORT_COMPLETE"
1875 }
1876 GetV1DomainsStatusesItemEnum::PendingRedemptionReportSubmitted => {
1877 "PENDING_REDEMPTION_REPORT_SUBMITTED"
1878 }
1879 GetV1DomainsStatusesItemEnum::PendingRedemptionWithoutReceipt => {
1880 "PENDING_REDEMPTION_WITHOUT_RECEIPT"
1881 }
1882 GetV1DomainsStatusesItemEnum::PendingRedemptionWithoutReceiptMock => {
1883 "PENDING_REDEMPTION_WITHOUT_RECEIPT_MOCK"
1884 }
1885 GetV1DomainsStatusesItemEnum::PendingReleasePremium => "PENDING_RELEASE_PREMIUM",
1886 GetV1DomainsStatusesItemEnum::PendingRemoval => "PENDING_REMOVAL",
1887 GetV1DomainsStatusesItemEnum::PendingRemovalHeld => "PENDING_REMOVAL_HELD",
1888 GetV1DomainsStatusesItemEnum::PendingRemovalParked => "PENDING_REMOVAL_PARKED",
1889 GetV1DomainsStatusesItemEnum::PendingRemovalUnpark => "PENDING_REMOVAL_UNPARK",
1890 GetV1DomainsStatusesItemEnum::PendingRenewal => "PENDING_RENEWAL",
1891 GetV1DomainsStatusesItemEnum::PendingRenewExpirationProtection => {
1892 "PENDING_RENEW_EXPIRATION_PROTECTION"
1893 }
1894 GetV1DomainsStatusesItemEnum::PendingRenewInfinite => "PENDING_RENEW_INFINITE",
1895 GetV1DomainsStatusesItemEnum::PendingRenewLocked => "PENDING_RENEW_LOCKED",
1896 GetV1DomainsStatusesItemEnum::PendingRenewWithoutReceipt => {
1897 "PENDING_RENEW_WITHOUT_RECEIPT"
1898 }
1899 GetV1DomainsStatusesItemEnum::PendingReportRedemptionWithoutReceipt => {
1900 "PENDING_REPORT_REDEMPTION_WITHOUT_RECEIPT"
1901 }
1902 GetV1DomainsStatusesItemEnum::PendingReservePremium => "PENDING_RESERVE_PREMIUM",
1903 GetV1DomainsStatusesItemEnum::PendingResetVerificationIcann => {
1904 "PENDING_RESET_VERIFICATION_ICANN"
1905 }
1906 GetV1DomainsStatusesItemEnum::PendingResponseFirehose => "PENDING_RESPONSE_FIREHOSE",
1907 GetV1DomainsStatusesItemEnum::PendingRestoration => "PENDING_RESTORATION",
1908 GetV1DomainsStatusesItemEnum::PendingRestorationInactive => {
1909 "PENDING_RESTORATION_INACTIVE"
1910 }
1911 GetV1DomainsStatusesItemEnum::PendingRestorationRedemptionMock => {
1912 "PENDING_RESTORATION_REDEMPTION_MOCK"
1913 }
1914 GetV1DomainsStatusesItemEnum::PendingRetryEppCreate => "PENDING_RETRY_EPP_CREATE",
1915 GetV1DomainsStatusesItemEnum::PendingRetryHeld => "PENDING_RETRY_HELD",
1916 GetV1DomainsStatusesItemEnum::PendingSendAuthCode => "PENDING_SEND_AUTH_CODE",
1917 GetV1DomainsStatusesItemEnum::PendingSetup => "PENDING_SETUP",
1918 GetV1DomainsStatusesItemEnum::PendingSetupAbandon => "PENDING_SETUP_ABANDON",
1919 GetV1DomainsStatusesItemEnum::PendingSetupAgreementLandrush => {
1920 "PENDING_SETUP_AGREEMENT_LANDRUSH"
1921 }
1922 GetV1DomainsStatusesItemEnum::PendingSetupAgreementSunrise2A => {
1923 "PENDING_SETUP_AGREEMENT_SUNRISE2_A"
1924 }
1925 GetV1DomainsStatusesItemEnum::PendingSetupAgreementSunrise2B => {
1926 "PENDING_SETUP_AGREEMENT_SUNRISE2_B"
1927 }
1928 GetV1DomainsStatusesItemEnum::PendingSetupAgreementSunrise2C => {
1929 "PENDING_SETUP_AGREEMENT_SUNRISE2_C"
1930 }
1931 GetV1DomainsStatusesItemEnum::PendingSetupAuth => "PENDING_SETUP_AUTH",
1932 GetV1DomainsStatusesItemEnum::PendingSetupDns => "PENDING_SETUP_DNS",
1933 GetV1DomainsStatusesItemEnum::PendingSetupFailed => "PENDING_SETUP_FAILED",
1934 GetV1DomainsStatusesItemEnum::PendingSetupReview => "PENDING_SETUP_REVIEW",
1935 GetV1DomainsStatusesItemEnum::PendingSetupSunrise => "PENDING_SETUP_SUNRISE",
1936 GetV1DomainsStatusesItemEnum::PendingSetupSunrisePre => "PENDING_SETUP_SUNRISE_PRE",
1937 GetV1DomainsStatusesItemEnum::PendingSetupSunriseResponse => {
1938 "PENDING_SETUP_SUNRISE_RESPONSE"
1939 }
1940 GetV1DomainsStatusesItemEnum::PendingSubmitFailure => "PENDING_SUBMIT_FAILURE",
1941 GetV1DomainsStatusesItemEnum::PendingSubmitFirehose => "PENDING_SUBMIT_FIREHOSE",
1942 GetV1DomainsStatusesItemEnum::PendingSubmitHoldFirehose => {
1943 "PENDING_SUBMIT_HOLD_FIREHOSE"
1944 }
1945 GetV1DomainsStatusesItemEnum::PendingSubmitHoldLandrush => {
1946 "PENDING_SUBMIT_HOLD_LANDRUSH"
1947 }
1948 GetV1DomainsStatusesItemEnum::PendingSubmitHoldSunrise => "PENDING_SUBMIT_HOLD_SUNRISE",
1949 GetV1DomainsStatusesItemEnum::PendingSubmitLandrush => "PENDING_SUBMIT_LANDRUSH",
1950 GetV1DomainsStatusesItemEnum::PendingSubmitResponseFirehose => {
1951 "PENDING_SUBMIT_RESPONSE_FIREHOSE"
1952 }
1953 GetV1DomainsStatusesItemEnum::PendingSubmitResponseLandrush => {
1954 "PENDING_SUBMIT_RESPONSE_LANDRUSH"
1955 }
1956 GetV1DomainsStatusesItemEnum::PendingSubmitResponseSunrise => {
1957 "PENDING_SUBMIT_RESPONSE_SUNRISE"
1958 }
1959 GetV1DomainsStatusesItemEnum::PendingSubmitSuccessFirehose => {
1960 "PENDING_SUBMIT_SUCCESS_FIREHOSE"
1961 }
1962 GetV1DomainsStatusesItemEnum::PendingSubmitSuccessLandrush => {
1963 "PENDING_SUBMIT_SUCCESS_LANDRUSH"
1964 }
1965 GetV1DomainsStatusesItemEnum::PendingSubmitSuccessSunrise => {
1966 "PENDING_SUBMIT_SUCCESS_SUNRISE"
1967 }
1968 GetV1DomainsStatusesItemEnum::PendingSubmitSunrise => "PENDING_SUBMIT_SUNRISE",
1969 GetV1DomainsStatusesItemEnum::PendingSubmitWaitingLandrush => {
1970 "PENDING_SUBMIT_WAITING_LANDRUSH"
1971 }
1972 GetV1DomainsStatusesItemEnum::PendingSuccessPreRegistration => {
1973 "PENDING_SUCCESS_PRE_REGISTRATION"
1974 }
1975 GetV1DomainsStatusesItemEnum::PendingSuspendedDataQuality => {
1976 "PENDING_SUSPENDED_DATA_QUALITY"
1977 }
1978 GetV1DomainsStatusesItemEnum::PendingTransferAckPremium => {
1979 "PENDING_TRANSFER_ACK_PREMIUM"
1980 }
1981 GetV1DomainsStatusesItemEnum::PendingTransferIn => "PENDING_TRANSFER_IN",
1982 GetV1DomainsStatusesItemEnum::PendingTransferInAck => "PENDING_TRANSFER_IN_ACK",
1983 GetV1DomainsStatusesItemEnum::PendingTransferInAckPremium => {
1984 "PENDING_TRANSFER_IN_ACK_PREMIUM"
1985 }
1986 GetV1DomainsStatusesItemEnum::PendingTransferInBadRegistrant => {
1987 "PENDING_TRANSFER_IN_BAD_REGISTRANT"
1988 }
1989 GetV1DomainsStatusesItemEnum::PendingTransferInCancel => "PENDING_TRANSFER_IN_CANCEL",
1990 GetV1DomainsStatusesItemEnum::PendingTransferInCancelRegistry => {
1991 "PENDING_TRANSFER_IN_CANCEL_REGISTRY"
1992 }
1993 GetV1DomainsStatusesItemEnum::PendingTransferInCompleteAck => {
1994 "PENDING_TRANSFER_IN_COMPLETE_ACK"
1995 }
1996 GetV1DomainsStatusesItemEnum::PendingTransferInDelete => "PENDING_TRANSFER_IN_DELETE",
1997 GetV1DomainsStatusesItemEnum::PendingTransferInLock => "PENDING_TRANSFER_IN_LOCK",
1998 GetV1DomainsStatusesItemEnum::PendingTransferInNack => "PENDING_TRANSFER_IN_NACK",
1999 GetV1DomainsStatusesItemEnum::PendingTransferInNotification => {
2000 "PENDING_TRANSFER_IN_NOTIFICATION"
2001 }
2002 GetV1DomainsStatusesItemEnum::PendingTransferInPremium => "PENDING_TRANSFER_IN_PREMIUM",
2003 GetV1DomainsStatusesItemEnum::PendingTransferInRelease => "PENDING_TRANSFER_IN_RELEASE",
2004 GetV1DomainsStatusesItemEnum::PendingTransferInResponse => {
2005 "PENDING_TRANSFER_IN_RESPONSE"
2006 }
2007 GetV1DomainsStatusesItemEnum::PendingTransferInUnderage => {
2008 "PENDING_TRANSFER_IN_UNDERAGE"
2009 }
2010 GetV1DomainsStatusesItemEnum::PendingTransferOut => "PENDING_TRANSFER_OUT",
2011 GetV1DomainsStatusesItemEnum::PendingTransferOutAck => "PENDING_TRANSFER_OUT_ACK",
2012 GetV1DomainsStatusesItemEnum::PendingTransferOutNack => "PENDING_TRANSFER_OUT_NACK",
2013 GetV1DomainsStatusesItemEnum::PendingTransferOutPremium => {
2014 "PENDING_TRANSFER_OUT_PREMIUM"
2015 }
2016 GetV1DomainsStatusesItemEnum::PendingTransferOutUnderage => {
2017 "PENDING_TRANSFER_OUT_UNDERAGE"
2018 }
2019 GetV1DomainsStatusesItemEnum::PendingTransferOutValidation => {
2020 "PENDING_TRANSFER_OUT_VALIDATION"
2021 }
2022 GetV1DomainsStatusesItemEnum::PendingTransferPremium => "PENDING_TRANSFER_PREMIUM",
2023 GetV1DomainsStatusesItemEnum::PendingTransferPremuim => "PENDING_TRANSFER_PREMUIM",
2024 GetV1DomainsStatusesItemEnum::PendingTransferSubmitPremium => {
2025 "PENDING_TRANSFER_SUBMIT_PREMIUM"
2026 }
2027 GetV1DomainsStatusesItemEnum::PendingUnlockDataQuality => "PENDING_UNLOCK_DATA_QUALITY",
2028 GetV1DomainsStatusesItemEnum::PendingUnlockPremium => "PENDING_UNLOCK_PREMIUM",
2029 GetV1DomainsStatusesItemEnum::PendingUpdate => "PENDING_UPDATE",
2030 GetV1DomainsStatusesItemEnum::PendingUpdatedRegistrantDataQuality => {
2031 "PENDING_UPDATED_REGISTRANT_DATA_QUALITY"
2032 }
2033 GetV1DomainsStatusesItemEnum::PendingUpdateAccount => "PENDING_UPDATE_ACCOUNT",
2034 GetV1DomainsStatusesItemEnum::PendingUpdateApi => "PENDING_UPDATE_API",
2035 GetV1DomainsStatusesItemEnum::PendingUpdateApiResponse => "PENDING_UPDATE_API_RESPONSE",
2036 GetV1DomainsStatusesItemEnum::PendingUpdateAuth => "PENDING_UPDATE_AUTH",
2037 GetV1DomainsStatusesItemEnum::PendingUpdateContacts => "PENDING_UPDATE_CONTACTS",
2038 GetV1DomainsStatusesItemEnum::PendingUpdateContactsPrivacy => {
2039 "PENDING_UPDATE_CONTACTS_PRIVACY"
2040 }
2041 GetV1DomainsStatusesItemEnum::PendingUpdateDns => "PENDING_UPDATE_DNS",
2042 GetV1DomainsStatusesItemEnum::PendingUpdateDnsSecurity => "PENDING_UPDATE_DNS_SECURITY",
2043 GetV1DomainsStatusesItemEnum::PendingUpdateEligibility => "PENDING_UPDATE_ELIGIBILITY",
2044 GetV1DomainsStatusesItemEnum::PendingUpdateEppContacts => "PENDING_UPDATE_EPP_CONTACTS",
2045 GetV1DomainsStatusesItemEnum::PendingUpdateMembership => "PENDING_UPDATE_MEMBERSHIP",
2046 GetV1DomainsStatusesItemEnum::PendingUpdateOwnership => "PENDING_UPDATE_OWNERSHIP",
2047 GetV1DomainsStatusesItemEnum::PendingUpdateOwnershipAuthAuction => {
2048 "PENDING_UPDATE_OWNERSHIP_AUTH_AUCTION"
2049 }
2050 GetV1DomainsStatusesItemEnum::PendingUpdateOwnershipHeld => {
2051 "PENDING_UPDATE_OWNERSHIP_HELD"
2052 }
2053 GetV1DomainsStatusesItemEnum::PendingUpdateRegistrant => "PENDING_UPDATE_REGISTRANT",
2054 GetV1DomainsStatusesItemEnum::PendingUpdateRepo => "PENDING_UPDATE_REPO",
2055 GetV1DomainsStatusesItemEnum::PendingValidationDataQuality => {
2056 "PENDING_VALIDATION_DATA_QUALITY"
2057 }
2058 GetV1DomainsStatusesItemEnum::PendingVerificationFraud => "PENDING_VERIFICATION_FRAUD",
2059 GetV1DomainsStatusesItemEnum::PendingVerificationStatus => {
2060 "PENDING_VERIFICATION_STATUS"
2061 }
2062 GetV1DomainsStatusesItemEnum::PendingVerifyRegistrantDataQuality => {
2063 "PENDING_VERIFY_REGISTRANT_DATA_QUALITY"
2064 }
2065 GetV1DomainsStatusesItemEnum::Reserved => "RESERVED",
2066 GetV1DomainsStatusesItemEnum::ReservedPremium => "RESERVED_PREMIUM",
2067 GetV1DomainsStatusesItemEnum::Reverted => "REVERTED",
2068 GetV1DomainsStatusesItemEnum::SuspendedVerificationIcann => {
2069 "SUSPENDED_VERIFICATION_ICANN"
2070 }
2071 GetV1DomainsStatusesItemEnum::TransferredOut => "TRANSFERRED_OUT",
2072 GetV1DomainsStatusesItemEnum::UnlockedAbuse => "UNLOCKED_ABUSE",
2073 GetV1DomainsStatusesItemEnum::UnlockedSuper => "UNLOCKED_SUPER",
2074 GetV1DomainsStatusesItemEnum::UnparkedAndUnheld => "UNPARKED_AND_UNHELD",
2075 GetV1DomainsStatusesItemEnum::UpdatedOwnership => "UPDATED_OWNERSHIP",
2076 GetV1DomainsStatusesItemEnum::UpdatedOwnershipHeld => "UPDATED_OWNERSHIP_HELD",
2077 };
2078 write!(f, "{}", str_val)
2079 }
2080}
2081#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
2082pub enum AddressCountryEnum {
2083 #[default]
2084 #[serde(rename = "AC")]
2085 Ac,
2086 #[serde(rename = "AD")]
2087 Ad,
2088 #[serde(rename = "AE")]
2089 Ae,
2090 #[serde(rename = "AF")]
2091 Af,
2092 #[serde(rename = "AG")]
2093 Ag,
2094 #[serde(rename = "AI")]
2095 Ai,
2096 #[serde(rename = "AL")]
2097 Al,
2098 #[serde(rename = "AM")]
2099 Am,
2100 #[serde(rename = "AO")]
2101 Ao,
2102 #[serde(rename = "AQ")]
2103 Aq,
2104 #[serde(rename = "AR")]
2105 Ar,
2106 #[serde(rename = "AS")]
2107 As,
2108 #[serde(rename = "AT")]
2109 At,
2110 #[serde(rename = "AU")]
2111 Au,
2112 #[serde(rename = "AW")]
2113 Aw,
2114 #[serde(rename = "AX")]
2115 Ax,
2116 #[serde(rename = "AZ")]
2117 Az,
2118 #[serde(rename = "BA")]
2119 Ba,
2120 #[serde(rename = "BB")]
2121 Bb,
2122 #[serde(rename = "BD")]
2123 Bd,
2124 #[serde(rename = "BE")]
2125 Be,
2126 #[serde(rename = "BF")]
2127 Bf,
2128 #[serde(rename = "BG")]
2129 Bg,
2130 #[serde(rename = "BH")]
2131 Bh,
2132 #[serde(rename = "BI")]
2133 Bi,
2134 #[serde(rename = "BJ")]
2135 Bj,
2136 #[serde(rename = "BM")]
2137 Bm,
2138 #[serde(rename = "BN")]
2139 Bn,
2140 #[serde(rename = "BO")]
2141 Bo,
2142 #[serde(rename = "BQ")]
2143 Bq,
2144 #[serde(rename = "BR")]
2145 Br,
2146 #[serde(rename = "BS")]
2147 Bs,
2148 #[serde(rename = "BT")]
2149 Bt,
2150 #[serde(rename = "BV")]
2151 Bv,
2152 #[serde(rename = "BW")]
2153 Bw,
2154 #[serde(rename = "BY")]
2155 By,
2156 #[serde(rename = "BZ")]
2157 Bz,
2158 #[serde(rename = "CA")]
2159 Ca,
2160 #[serde(rename = "CC")]
2161 Cc,
2162 #[serde(rename = "CD")]
2163 Cd,
2164 #[serde(rename = "CF")]
2165 Cf,
2166 #[serde(rename = "CG")]
2167 Cg,
2168 #[serde(rename = "CH")]
2169 Ch,
2170 #[serde(rename = "CI")]
2171 Ci,
2172 #[serde(rename = "CK")]
2173 Ck,
2174 #[serde(rename = "CL")]
2175 Cl,
2176 #[serde(rename = "CM")]
2177 Cm,
2178 #[serde(rename = "CN")]
2179 Cn,
2180 #[serde(rename = "CO")]
2181 Co,
2182 #[serde(rename = "CR")]
2183 Cr,
2184 #[serde(rename = "CV")]
2185 Cv,
2186 #[serde(rename = "CW")]
2187 Cw,
2188 #[serde(rename = "CX")]
2189 Cx,
2190 #[serde(rename = "CY")]
2191 Cy,
2192 #[serde(rename = "CZ")]
2193 Cz,
2194 #[serde(rename = "DE")]
2195 De,
2196 #[serde(rename = "DJ")]
2197 Dj,
2198 #[serde(rename = "DK")]
2199 Dk,
2200 #[serde(rename = "DM")]
2201 Dm,
2202 #[serde(rename = "DO")]
2203 Do,
2204 #[serde(rename = "DZ")]
2205 Dz,
2206 #[serde(rename = "EC")]
2207 Ec,
2208 #[serde(rename = "EE")]
2209 Ee,
2210 #[serde(rename = "EG")]
2211 Eg,
2212 #[serde(rename = "EH")]
2213 Eh,
2214 #[serde(rename = "ER")]
2215 Er,
2216 #[serde(rename = "ES")]
2217 Es,
2218 #[serde(rename = "ET")]
2219 Et,
2220 #[serde(rename = "FI")]
2221 Fi,
2222 #[serde(rename = "FJ")]
2223 Fj,
2224 #[serde(rename = "FK")]
2225 Fk,
2226 #[serde(rename = "FM")]
2227 Fm,
2228 #[serde(rename = "FO")]
2229 Fo,
2230 #[serde(rename = "FR")]
2231 Fr,
2232 #[serde(rename = "GA")]
2233 Ga,
2234 #[serde(rename = "GB")]
2235 Gb,
2236 #[serde(rename = "GD")]
2237 Gd,
2238 #[serde(rename = "GE")]
2239 Ge,
2240 #[serde(rename = "GF")]
2241 Gf,
2242 #[serde(rename = "GG")]
2243 Gg,
2244 #[serde(rename = "GH")]
2245 Gh,
2246 #[serde(rename = "GI")]
2247 Gi,
2248 #[serde(rename = "GL")]
2249 Gl,
2250 #[serde(rename = "GM")]
2251 Gm,
2252 #[serde(rename = "GN")]
2253 Gn,
2254 #[serde(rename = "GP")]
2255 Gp,
2256 #[serde(rename = "GQ")]
2257 Gq,
2258 #[serde(rename = "GR")]
2259 Gr,
2260 #[serde(rename = "GS")]
2261 Gs,
2262 #[serde(rename = "GT")]
2263 Gt,
2264 #[serde(rename = "GU")]
2265 Gu,
2266 #[serde(rename = "GW")]
2267 Gw,
2268 #[serde(rename = "GY")]
2269 Gy,
2270 #[serde(rename = "HK")]
2271 Hk,
2272 #[serde(rename = "HM")]
2273 Hm,
2274 #[serde(rename = "HN")]
2275 Hn,
2276 #[serde(rename = "HR")]
2277 Hr,
2278 #[serde(rename = "HT")]
2279 Ht,
2280 #[serde(rename = "HU")]
2281 Hu,
2282 #[serde(rename = "ID")]
2283 Id,
2284 #[serde(rename = "IE")]
2285 Ie,
2286 #[serde(rename = "IL")]
2287 Il,
2288 #[serde(rename = "IM")]
2289 Im,
2290 #[serde(rename = "IN")]
2291 In,
2292 #[serde(rename = "IO")]
2293 Io,
2294 #[serde(rename = "IQ")]
2295 Iq,
2296 #[serde(rename = "IS")]
2297 Is,
2298 #[serde(rename = "IT")]
2299 It,
2300 #[serde(rename = "JE")]
2301 Je,
2302 #[serde(rename = "JM")]
2303 Jm,
2304 #[serde(rename = "JO")]
2305 Jo,
2306 #[serde(rename = "JP")]
2307 Jp,
2308 #[serde(rename = "KE")]
2309 Ke,
2310 #[serde(rename = "KG")]
2311 Kg,
2312 #[serde(rename = "KH")]
2313 Kh,
2314 #[serde(rename = "KI")]
2315 Ki,
2316 #[serde(rename = "KM")]
2317 Km,
2318 #[serde(rename = "KN")]
2319 Kn,
2320 #[serde(rename = "KR")]
2321 Kr,
2322 #[serde(rename = "KV")]
2323 Kv,
2324 #[serde(rename = "KW")]
2325 Kw,
2326 #[serde(rename = "KY")]
2327 Ky,
2328 #[serde(rename = "KZ")]
2329 Kz,
2330 #[serde(rename = "LA")]
2331 La,
2332 #[serde(rename = "LB")]
2333 Lb,
2334 #[serde(rename = "LC")]
2335 Lc,
2336 #[serde(rename = "LI")]
2337 Li,
2338 #[serde(rename = "LK")]
2339 Lk,
2340 #[serde(rename = "LR")]
2341 Lr,
2342 #[serde(rename = "LS")]
2343 Ls,
2344 #[serde(rename = "LT")]
2345 Lt,
2346 #[serde(rename = "LU")]
2347 Lu,
2348 #[serde(rename = "LV")]
2349 Lv,
2350 #[serde(rename = "LY")]
2351 Ly,
2352 #[serde(rename = "MA")]
2353 Ma,
2354 #[serde(rename = "MC")]
2355 Mc,
2356 #[serde(rename = "MD")]
2357 Md,
2358 #[serde(rename = "ME")]
2359 Me,
2360 #[serde(rename = "MG")]
2361 Mg,
2362 #[serde(rename = "MH")]
2363 Mh,
2364 #[serde(rename = "MK")]
2365 Mk,
2366 #[serde(rename = "ML")]
2367 Ml,
2368 #[serde(rename = "MM")]
2369 Mm,
2370 #[serde(rename = "MN")]
2371 Mn,
2372 #[serde(rename = "MO")]
2373 Mo,
2374 #[serde(rename = "MP")]
2375 Mp,
2376 #[serde(rename = "MQ")]
2377 Mq,
2378 #[serde(rename = "MR")]
2379 Mr,
2380 #[serde(rename = "MS")]
2381 Ms,
2382 #[serde(rename = "MT")]
2383 Mt,
2384 #[serde(rename = "MU")]
2385 Mu,
2386 #[serde(rename = "MV")]
2387 Mv,
2388 #[serde(rename = "MW")]
2389 Mw,
2390 #[serde(rename = "MX")]
2391 Mx,
2392 #[serde(rename = "MY")]
2393 My,
2394 #[serde(rename = "MZ")]
2395 Mz,
2396 #[serde(rename = "NA")]
2397 Na,
2398 #[serde(rename = "NC")]
2399 Nc,
2400 #[serde(rename = "NE")]
2401 Ne,
2402 #[serde(rename = "NF")]
2403 Nf,
2404 #[serde(rename = "NG")]
2405 Ng,
2406 #[serde(rename = "NI")]
2407 Ni,
2408 #[serde(rename = "NL")]
2409 Nl,
2410 #[serde(rename = "NO")]
2411 No,
2412 #[serde(rename = "NP")]
2413 Np,
2414 #[serde(rename = "NR")]
2415 Nr,
2416 #[serde(rename = "NU")]
2417 Nu,
2418 #[serde(rename = "NZ")]
2419 Nz,
2420 #[serde(rename = "OM")]
2421 Om,
2422 #[serde(rename = "PA")]
2423 Pa,
2424 #[serde(rename = "PE")]
2425 Pe,
2426 #[serde(rename = "PF")]
2427 Pf,
2428 #[serde(rename = "PG")]
2429 Pg,
2430 #[serde(rename = "PH")]
2431 Ph,
2432 #[serde(rename = "PK")]
2433 Pk,
2434 #[serde(rename = "PL")]
2435 Pl,
2436 #[serde(rename = "PM")]
2437 Pm,
2438 #[serde(rename = "PN")]
2439 Pn,
2440 #[serde(rename = "PR")]
2441 Pr,
2442 #[serde(rename = "PS")]
2443 Ps,
2444 #[serde(rename = "PT")]
2445 Pt,
2446 #[serde(rename = "PW")]
2447 Pw,
2448 #[serde(rename = "PY")]
2449 Py,
2450 #[serde(rename = "QA")]
2451 Qa,
2452 #[serde(rename = "RE")]
2453 Re,
2454 #[serde(rename = "RO")]
2455 Ro,
2456 #[serde(rename = "RS")]
2457 Rs,
2458 #[serde(rename = "RU")]
2459 Ru,
2460 #[serde(rename = "RW")]
2461 Rw,
2462 #[serde(rename = "SA")]
2463 Sa,
2464 #[serde(rename = "SB")]
2465 Sb,
2466 #[serde(rename = "SC")]
2467 Sc,
2468 #[serde(rename = "SE")]
2469 Se,
2470 #[serde(rename = "SG")]
2471 Sg,
2472 #[serde(rename = "SH")]
2473 Sh,
2474 #[serde(rename = "SI")]
2475 Si,
2476 #[serde(rename = "SJ")]
2477 Sj,
2478 #[serde(rename = "SK")]
2479 Sk,
2480 #[serde(rename = "SL")]
2481 Sl,
2482 #[serde(rename = "SM")]
2483 Sm,
2484 #[serde(rename = "SN")]
2485 Sn,
2486 #[serde(rename = "SO")]
2487 So,
2488 #[serde(rename = "SR")]
2489 Sr,
2490 #[serde(rename = "ST")]
2491 St,
2492 #[serde(rename = "SV")]
2493 Sv,
2494 #[serde(rename = "SX")]
2495 Sx,
2496 #[serde(rename = "SZ")]
2497 Sz,
2498 #[serde(rename = "TC")]
2499 Tc,
2500 #[serde(rename = "TD")]
2501 Td,
2502 #[serde(rename = "TF")]
2503 Tf,
2504 #[serde(rename = "TG")]
2505 Tg,
2506 #[serde(rename = "TH")]
2507 Th,
2508 #[serde(rename = "TJ")]
2509 Tj,
2510 #[serde(rename = "TK")]
2511 Tk,
2512 #[serde(rename = "TL")]
2513 Tl,
2514 #[serde(rename = "TM")]
2515 Tm,
2516 #[serde(rename = "TN")]
2517 Tn,
2518 #[serde(rename = "TO")]
2519 To,
2520 #[serde(rename = "TP")]
2521 Tp,
2522 #[serde(rename = "TR")]
2523 Tr,
2524 #[serde(rename = "TT")]
2525 Tt,
2526 #[serde(rename = "TV")]
2527 Tv,
2528 #[serde(rename = "TW")]
2529 Tw,
2530 #[serde(rename = "TZ")]
2531 Tz,
2532 #[serde(rename = "UA")]
2533 Ua,
2534 #[serde(rename = "UG")]
2535 Ug,
2536 #[serde(rename = "UM")]
2537 Um,
2538 #[serde(rename = "US")]
2539 Us,
2540 #[serde(rename = "UY")]
2541 Uy,
2542 #[serde(rename = "UZ")]
2543 Uz,
2544 #[serde(rename = "VA")]
2545 Va,
2546 #[serde(rename = "VC")]
2547 Vc,
2548 #[serde(rename = "VE")]
2549 Ve,
2550 #[serde(rename = "VG")]
2551 Vg,
2552 #[serde(rename = "VI")]
2553 Vi,
2554 #[serde(rename = "VN")]
2555 Vn,
2556 #[serde(rename = "VU")]
2557 Vu,
2558 #[serde(rename = "WF")]
2559 Wf,
2560 #[serde(rename = "WS")]
2561 Ws,
2562 #[serde(rename = "YE")]
2563 Ye,
2564 #[serde(rename = "YT")]
2565 Yt,
2566 #[serde(rename = "ZA")]
2567 Za,
2568 #[serde(rename = "ZM")]
2569 Zm,
2570 #[serde(rename = "ZW")]
2571 Zw,
2572}
2573impl std::fmt::Display for AddressCountryEnum {
2574 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2575 let str_val = match self {
2576 AddressCountryEnum::Ac => "AC",
2577 AddressCountryEnum::Ad => "AD",
2578 AddressCountryEnum::Ae => "AE",
2579 AddressCountryEnum::Af => "AF",
2580 AddressCountryEnum::Ag => "AG",
2581 AddressCountryEnum::Ai => "AI",
2582 AddressCountryEnum::Al => "AL",
2583 AddressCountryEnum::Am => "AM",
2584 AddressCountryEnum::Ao => "AO",
2585 AddressCountryEnum::Aq => "AQ",
2586 AddressCountryEnum::Ar => "AR",
2587 AddressCountryEnum::As => "AS",
2588 AddressCountryEnum::At => "AT",
2589 AddressCountryEnum::Au => "AU",
2590 AddressCountryEnum::Aw => "AW",
2591 AddressCountryEnum::Ax => "AX",
2592 AddressCountryEnum::Az => "AZ",
2593 AddressCountryEnum::Ba => "BA",
2594 AddressCountryEnum::Bb => "BB",
2595 AddressCountryEnum::Bd => "BD",
2596 AddressCountryEnum::Be => "BE",
2597 AddressCountryEnum::Bf => "BF",
2598 AddressCountryEnum::Bg => "BG",
2599 AddressCountryEnum::Bh => "BH",
2600 AddressCountryEnum::Bi => "BI",
2601 AddressCountryEnum::Bj => "BJ",
2602 AddressCountryEnum::Bm => "BM",
2603 AddressCountryEnum::Bn => "BN",
2604 AddressCountryEnum::Bo => "BO",
2605 AddressCountryEnum::Bq => "BQ",
2606 AddressCountryEnum::Br => "BR",
2607 AddressCountryEnum::Bs => "BS",
2608 AddressCountryEnum::Bt => "BT",
2609 AddressCountryEnum::Bv => "BV",
2610 AddressCountryEnum::Bw => "BW",
2611 AddressCountryEnum::By => "BY",
2612 AddressCountryEnum::Bz => "BZ",
2613 AddressCountryEnum::Ca => "CA",
2614 AddressCountryEnum::Cc => "CC",
2615 AddressCountryEnum::Cd => "CD",
2616 AddressCountryEnum::Cf => "CF",
2617 AddressCountryEnum::Cg => "CG",
2618 AddressCountryEnum::Ch => "CH",
2619 AddressCountryEnum::Ci => "CI",
2620 AddressCountryEnum::Ck => "CK",
2621 AddressCountryEnum::Cl => "CL",
2622 AddressCountryEnum::Cm => "CM",
2623 AddressCountryEnum::Cn => "CN",
2624 AddressCountryEnum::Co => "CO",
2625 AddressCountryEnum::Cr => "CR",
2626 AddressCountryEnum::Cv => "CV",
2627 AddressCountryEnum::Cw => "CW",
2628 AddressCountryEnum::Cx => "CX",
2629 AddressCountryEnum::Cy => "CY",
2630 AddressCountryEnum::Cz => "CZ",
2631 AddressCountryEnum::De => "DE",
2632 AddressCountryEnum::Dj => "DJ",
2633 AddressCountryEnum::Dk => "DK",
2634 AddressCountryEnum::Dm => "DM",
2635 AddressCountryEnum::Do => "DO",
2636 AddressCountryEnum::Dz => "DZ",
2637 AddressCountryEnum::Ec => "EC",
2638 AddressCountryEnum::Ee => "EE",
2639 AddressCountryEnum::Eg => "EG",
2640 AddressCountryEnum::Eh => "EH",
2641 AddressCountryEnum::Er => "ER",
2642 AddressCountryEnum::Es => "ES",
2643 AddressCountryEnum::Et => "ET",
2644 AddressCountryEnum::Fi => "FI",
2645 AddressCountryEnum::Fj => "FJ",
2646 AddressCountryEnum::Fk => "FK",
2647 AddressCountryEnum::Fm => "FM",
2648 AddressCountryEnum::Fo => "FO",
2649 AddressCountryEnum::Fr => "FR",
2650 AddressCountryEnum::Ga => "GA",
2651 AddressCountryEnum::Gb => "GB",
2652 AddressCountryEnum::Gd => "GD",
2653 AddressCountryEnum::Ge => "GE",
2654 AddressCountryEnum::Gf => "GF",
2655 AddressCountryEnum::Gg => "GG",
2656 AddressCountryEnum::Gh => "GH",
2657 AddressCountryEnum::Gi => "GI",
2658 AddressCountryEnum::Gl => "GL",
2659 AddressCountryEnum::Gm => "GM",
2660 AddressCountryEnum::Gn => "GN",
2661 AddressCountryEnum::Gp => "GP",
2662 AddressCountryEnum::Gq => "GQ",
2663 AddressCountryEnum::Gr => "GR",
2664 AddressCountryEnum::Gs => "GS",
2665 AddressCountryEnum::Gt => "GT",
2666 AddressCountryEnum::Gu => "GU",
2667 AddressCountryEnum::Gw => "GW",
2668 AddressCountryEnum::Gy => "GY",
2669 AddressCountryEnum::Hk => "HK",
2670 AddressCountryEnum::Hm => "HM",
2671 AddressCountryEnum::Hn => "HN",
2672 AddressCountryEnum::Hr => "HR",
2673 AddressCountryEnum::Ht => "HT",
2674 AddressCountryEnum::Hu => "HU",
2675 AddressCountryEnum::Id => "ID",
2676 AddressCountryEnum::Ie => "IE",
2677 AddressCountryEnum::Il => "IL",
2678 AddressCountryEnum::Im => "IM",
2679 AddressCountryEnum::In => "IN",
2680 AddressCountryEnum::Io => "IO",
2681 AddressCountryEnum::Iq => "IQ",
2682 AddressCountryEnum::Is => "IS",
2683 AddressCountryEnum::It => "IT",
2684 AddressCountryEnum::Je => "JE",
2685 AddressCountryEnum::Jm => "JM",
2686 AddressCountryEnum::Jo => "JO",
2687 AddressCountryEnum::Jp => "JP",
2688 AddressCountryEnum::Ke => "KE",
2689 AddressCountryEnum::Kg => "KG",
2690 AddressCountryEnum::Kh => "KH",
2691 AddressCountryEnum::Ki => "KI",
2692 AddressCountryEnum::Km => "KM",
2693 AddressCountryEnum::Kn => "KN",
2694 AddressCountryEnum::Kr => "KR",
2695 AddressCountryEnum::Kv => "KV",
2696 AddressCountryEnum::Kw => "KW",
2697 AddressCountryEnum::Ky => "KY",
2698 AddressCountryEnum::Kz => "KZ",
2699 AddressCountryEnum::La => "LA",
2700 AddressCountryEnum::Lb => "LB",
2701 AddressCountryEnum::Lc => "LC",
2702 AddressCountryEnum::Li => "LI",
2703 AddressCountryEnum::Lk => "LK",
2704 AddressCountryEnum::Lr => "LR",
2705 AddressCountryEnum::Ls => "LS",
2706 AddressCountryEnum::Lt => "LT",
2707 AddressCountryEnum::Lu => "LU",
2708 AddressCountryEnum::Lv => "LV",
2709 AddressCountryEnum::Ly => "LY",
2710 AddressCountryEnum::Ma => "MA",
2711 AddressCountryEnum::Mc => "MC",
2712 AddressCountryEnum::Md => "MD",
2713 AddressCountryEnum::Me => "ME",
2714 AddressCountryEnum::Mg => "MG",
2715 AddressCountryEnum::Mh => "MH",
2716 AddressCountryEnum::Mk => "MK",
2717 AddressCountryEnum::Ml => "ML",
2718 AddressCountryEnum::Mm => "MM",
2719 AddressCountryEnum::Mn => "MN",
2720 AddressCountryEnum::Mo => "MO",
2721 AddressCountryEnum::Mp => "MP",
2722 AddressCountryEnum::Mq => "MQ",
2723 AddressCountryEnum::Mr => "MR",
2724 AddressCountryEnum::Ms => "MS",
2725 AddressCountryEnum::Mt => "MT",
2726 AddressCountryEnum::Mu => "MU",
2727 AddressCountryEnum::Mv => "MV",
2728 AddressCountryEnum::Mw => "MW",
2729 AddressCountryEnum::Mx => "MX",
2730 AddressCountryEnum::My => "MY",
2731 AddressCountryEnum::Mz => "MZ",
2732 AddressCountryEnum::Na => "NA",
2733 AddressCountryEnum::Nc => "NC",
2734 AddressCountryEnum::Ne => "NE",
2735 AddressCountryEnum::Nf => "NF",
2736 AddressCountryEnum::Ng => "NG",
2737 AddressCountryEnum::Ni => "NI",
2738 AddressCountryEnum::Nl => "NL",
2739 AddressCountryEnum::No => "NO",
2740 AddressCountryEnum::Np => "NP",
2741 AddressCountryEnum::Nr => "NR",
2742 AddressCountryEnum::Nu => "NU",
2743 AddressCountryEnum::Nz => "NZ",
2744 AddressCountryEnum::Om => "OM",
2745 AddressCountryEnum::Pa => "PA",
2746 AddressCountryEnum::Pe => "PE",
2747 AddressCountryEnum::Pf => "PF",
2748 AddressCountryEnum::Pg => "PG",
2749 AddressCountryEnum::Ph => "PH",
2750 AddressCountryEnum::Pk => "PK",
2751 AddressCountryEnum::Pl => "PL",
2752 AddressCountryEnum::Pm => "PM",
2753 AddressCountryEnum::Pn => "PN",
2754 AddressCountryEnum::Pr => "PR",
2755 AddressCountryEnum::Ps => "PS",
2756 AddressCountryEnum::Pt => "PT",
2757 AddressCountryEnum::Pw => "PW",
2758 AddressCountryEnum::Py => "PY",
2759 AddressCountryEnum::Qa => "QA",
2760 AddressCountryEnum::Re => "RE",
2761 AddressCountryEnum::Ro => "RO",
2762 AddressCountryEnum::Rs => "RS",
2763 AddressCountryEnum::Ru => "RU",
2764 AddressCountryEnum::Rw => "RW",
2765 AddressCountryEnum::Sa => "SA",
2766 AddressCountryEnum::Sb => "SB",
2767 AddressCountryEnum::Sc => "SC",
2768 AddressCountryEnum::Se => "SE",
2769 AddressCountryEnum::Sg => "SG",
2770 AddressCountryEnum::Sh => "SH",
2771 AddressCountryEnum::Si => "SI",
2772 AddressCountryEnum::Sj => "SJ",
2773 AddressCountryEnum::Sk => "SK",
2774 AddressCountryEnum::Sl => "SL",
2775 AddressCountryEnum::Sm => "SM",
2776 AddressCountryEnum::Sn => "SN",
2777 AddressCountryEnum::So => "SO",
2778 AddressCountryEnum::Sr => "SR",
2779 AddressCountryEnum::St => "ST",
2780 AddressCountryEnum::Sv => "SV",
2781 AddressCountryEnum::Sx => "SX",
2782 AddressCountryEnum::Sz => "SZ",
2783 AddressCountryEnum::Tc => "TC",
2784 AddressCountryEnum::Td => "TD",
2785 AddressCountryEnum::Tf => "TF",
2786 AddressCountryEnum::Tg => "TG",
2787 AddressCountryEnum::Th => "TH",
2788 AddressCountryEnum::Tj => "TJ",
2789 AddressCountryEnum::Tk => "TK",
2790 AddressCountryEnum::Tl => "TL",
2791 AddressCountryEnum::Tm => "TM",
2792 AddressCountryEnum::Tn => "TN",
2793 AddressCountryEnum::To => "TO",
2794 AddressCountryEnum::Tp => "TP",
2795 AddressCountryEnum::Tr => "TR",
2796 AddressCountryEnum::Tt => "TT",
2797 AddressCountryEnum::Tv => "TV",
2798 AddressCountryEnum::Tw => "TW",
2799 AddressCountryEnum::Tz => "TZ",
2800 AddressCountryEnum::Ua => "UA",
2801 AddressCountryEnum::Ug => "UG",
2802 AddressCountryEnum::Um => "UM",
2803 AddressCountryEnum::Us => "US",
2804 AddressCountryEnum::Uy => "UY",
2805 AddressCountryEnum::Uz => "UZ",
2806 AddressCountryEnum::Va => "VA",
2807 AddressCountryEnum::Vc => "VC",
2808 AddressCountryEnum::Ve => "VE",
2809 AddressCountryEnum::Vg => "VG",
2810 AddressCountryEnum::Vi => "VI",
2811 AddressCountryEnum::Vn => "VN",
2812 AddressCountryEnum::Vu => "VU",
2813 AddressCountryEnum::Wf => "WF",
2814 AddressCountryEnum::Ws => "WS",
2815 AddressCountryEnum::Ye => "YE",
2816 AddressCountryEnum::Yt => "YT",
2817 AddressCountryEnum::Za => "ZA",
2818 AddressCountryEnum::Zm => "ZM",
2819 AddressCountryEnum::Zw => "ZW",
2820 };
2821 write!(f, "{}", str_val)
2822 }
2823}
2824#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
2825pub enum GetV1DomainsAvailableCheckTypeEnum {
2826 #[default]
2827 #[serde(rename = "FAST")]
2828 Fast,
2829 #[serde(rename = "FULL")]
2830 Full,
2831}
2832impl std::fmt::Display for GetV1DomainsAvailableCheckTypeEnum {
2833 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2834 let str_val = match self {
2835 GetV1DomainsAvailableCheckTypeEnum::Fast => "FAST",
2836 GetV1DomainsAvailableCheckTypeEnum::Full => "FULL",
2837 };
2838 write!(f, "{}", str_val)
2839 }
2840}
2841#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
2842pub enum GetV1DomainsSuggestCountryEnum {
2843 #[default]
2844 #[serde(rename = "AC")]
2845 Ac,
2846 #[serde(rename = "AD")]
2847 Ad,
2848 #[serde(rename = "AE")]
2849 Ae,
2850 #[serde(rename = "AF")]
2851 Af,
2852 #[serde(rename = "AG")]
2853 Ag,
2854 #[serde(rename = "AI")]
2855 Ai,
2856 #[serde(rename = "AL")]
2857 Al,
2858 #[serde(rename = "AM")]
2859 Am,
2860 #[serde(rename = "AO")]
2861 Ao,
2862 #[serde(rename = "AQ")]
2863 Aq,
2864 #[serde(rename = "AR")]
2865 Ar,
2866 #[serde(rename = "AS")]
2867 As,
2868 #[serde(rename = "AT")]
2869 At,
2870 #[serde(rename = "AU")]
2871 Au,
2872 #[serde(rename = "AW")]
2873 Aw,
2874 #[serde(rename = "AX")]
2875 Ax,
2876 #[serde(rename = "AZ")]
2877 Az,
2878 #[serde(rename = "BA")]
2879 Ba,
2880 #[serde(rename = "BB")]
2881 Bb,
2882 #[serde(rename = "BD")]
2883 Bd,
2884 #[serde(rename = "BE")]
2885 Be,
2886 #[serde(rename = "BF")]
2887 Bf,
2888 #[serde(rename = "BG")]
2889 Bg,
2890 #[serde(rename = "BH")]
2891 Bh,
2892 #[serde(rename = "BI")]
2893 Bi,
2894 #[serde(rename = "BJ")]
2895 Bj,
2896 #[serde(rename = "BM")]
2897 Bm,
2898 #[serde(rename = "BN")]
2899 Bn,
2900 #[serde(rename = "BO")]
2901 Bo,
2902 #[serde(rename = "BQ")]
2903 Bq,
2904 #[serde(rename = "BR")]
2905 Br,
2906 #[serde(rename = "BS")]
2907 Bs,
2908 #[serde(rename = "BT")]
2909 Bt,
2910 #[serde(rename = "BV")]
2911 Bv,
2912 #[serde(rename = "BW")]
2913 Bw,
2914 #[serde(rename = "BY")]
2915 By,
2916 #[serde(rename = "BZ")]
2917 Bz,
2918 #[serde(rename = "CA")]
2919 Ca,
2920 #[serde(rename = "CC")]
2921 Cc,
2922 #[serde(rename = "CD")]
2923 Cd,
2924 #[serde(rename = "CF")]
2925 Cf,
2926 #[serde(rename = "CG")]
2927 Cg,
2928 #[serde(rename = "CH")]
2929 Ch,
2930 #[serde(rename = "CI")]
2931 Ci,
2932 #[serde(rename = "CK")]
2933 Ck,
2934 #[serde(rename = "CL")]
2935 Cl,
2936 #[serde(rename = "CM")]
2937 Cm,
2938 #[serde(rename = "CN")]
2939 Cn,
2940 #[serde(rename = "CO")]
2941 Co,
2942 #[serde(rename = "CR")]
2943 Cr,
2944 #[serde(rename = "CV")]
2945 Cv,
2946 #[serde(rename = "CW")]
2947 Cw,
2948 #[serde(rename = "CX")]
2949 Cx,
2950 #[serde(rename = "CY")]
2951 Cy,
2952 #[serde(rename = "CZ")]
2953 Cz,
2954 #[serde(rename = "DE")]
2955 De,
2956 #[serde(rename = "DJ")]
2957 Dj,
2958 #[serde(rename = "DK")]
2959 Dk,
2960 #[serde(rename = "DM")]
2961 Dm,
2962 #[serde(rename = "DO")]
2963 Do,
2964 #[serde(rename = "DZ")]
2965 Dz,
2966 #[serde(rename = "EC")]
2967 Ec,
2968 #[serde(rename = "EE")]
2969 Ee,
2970 #[serde(rename = "EG")]
2971 Eg,
2972 #[serde(rename = "EH")]
2973 Eh,
2974 #[serde(rename = "ER")]
2975 Er,
2976 #[serde(rename = "ES")]
2977 Es,
2978 #[serde(rename = "ET")]
2979 Et,
2980 #[serde(rename = "FI")]
2981 Fi,
2982 #[serde(rename = "FJ")]
2983 Fj,
2984 #[serde(rename = "FK")]
2985 Fk,
2986 #[serde(rename = "FM")]
2987 Fm,
2988 #[serde(rename = "FO")]
2989 Fo,
2990 #[serde(rename = "FR")]
2991 Fr,
2992 #[serde(rename = "GA")]
2993 Ga,
2994 #[serde(rename = "GB")]
2995 Gb,
2996 #[serde(rename = "GD")]
2997 Gd,
2998 #[serde(rename = "GE")]
2999 Ge,
3000 #[serde(rename = "GF")]
3001 Gf,
3002 #[serde(rename = "GG")]
3003 Gg,
3004 #[serde(rename = "GH")]
3005 Gh,
3006 #[serde(rename = "GI")]
3007 Gi,
3008 #[serde(rename = "GL")]
3009 Gl,
3010 #[serde(rename = "GM")]
3011 Gm,
3012 #[serde(rename = "GN")]
3013 Gn,
3014 #[serde(rename = "GP")]
3015 Gp,
3016 #[serde(rename = "GQ")]
3017 Gq,
3018 #[serde(rename = "GR")]
3019 Gr,
3020 #[serde(rename = "GS")]
3021 Gs,
3022 #[serde(rename = "GT")]
3023 Gt,
3024 #[serde(rename = "GU")]
3025 Gu,
3026 #[serde(rename = "GW")]
3027 Gw,
3028 #[serde(rename = "GY")]
3029 Gy,
3030 #[serde(rename = "HK")]
3031 Hk,
3032 #[serde(rename = "HM")]
3033 Hm,
3034 #[serde(rename = "HN")]
3035 Hn,
3036 #[serde(rename = "HR")]
3037 Hr,
3038 #[serde(rename = "HT")]
3039 Ht,
3040 #[serde(rename = "HU")]
3041 Hu,
3042 #[serde(rename = "ID")]
3043 Id,
3044 #[serde(rename = "IE")]
3045 Ie,
3046 #[serde(rename = "IL")]
3047 Il,
3048 #[serde(rename = "IM")]
3049 Im,
3050 #[serde(rename = "IN")]
3051 In,
3052 #[serde(rename = "IO")]
3053 Io,
3054 #[serde(rename = "IQ")]
3055 Iq,
3056 #[serde(rename = "IS")]
3057 Is,
3058 #[serde(rename = "IT")]
3059 It,
3060 #[serde(rename = "JE")]
3061 Je,
3062 #[serde(rename = "JM")]
3063 Jm,
3064 #[serde(rename = "JO")]
3065 Jo,
3066 #[serde(rename = "JP")]
3067 Jp,
3068 #[serde(rename = "KE")]
3069 Ke,
3070 #[serde(rename = "KG")]
3071 Kg,
3072 #[serde(rename = "KH")]
3073 Kh,
3074 #[serde(rename = "KI")]
3075 Ki,
3076 #[serde(rename = "KM")]
3077 Km,
3078 #[serde(rename = "KN")]
3079 Kn,
3080 #[serde(rename = "KR")]
3081 Kr,
3082 #[serde(rename = "KV")]
3083 Kv,
3084 #[serde(rename = "KW")]
3085 Kw,
3086 #[serde(rename = "KY")]
3087 Ky,
3088 #[serde(rename = "KZ")]
3089 Kz,
3090 #[serde(rename = "LA")]
3091 La,
3092 #[serde(rename = "LB")]
3093 Lb,
3094 #[serde(rename = "LC")]
3095 Lc,
3096 #[serde(rename = "LI")]
3097 Li,
3098 #[serde(rename = "LK")]
3099 Lk,
3100 #[serde(rename = "LR")]
3101 Lr,
3102 #[serde(rename = "LS")]
3103 Ls,
3104 #[serde(rename = "LT")]
3105 Lt,
3106 #[serde(rename = "LU")]
3107 Lu,
3108 #[serde(rename = "LV")]
3109 Lv,
3110 #[serde(rename = "LY")]
3111 Ly,
3112 #[serde(rename = "MA")]
3113 Ma,
3114 #[serde(rename = "MC")]
3115 Mc,
3116 #[serde(rename = "MD")]
3117 Md,
3118 #[serde(rename = "ME")]
3119 Me,
3120 #[serde(rename = "MG")]
3121 Mg,
3122 #[serde(rename = "MH")]
3123 Mh,
3124 #[serde(rename = "MK")]
3125 Mk,
3126 #[serde(rename = "ML")]
3127 Ml,
3128 #[serde(rename = "MM")]
3129 Mm,
3130 #[serde(rename = "MN")]
3131 Mn,
3132 #[serde(rename = "MO")]
3133 Mo,
3134 #[serde(rename = "MP")]
3135 Mp,
3136 #[serde(rename = "MQ")]
3137 Mq,
3138 #[serde(rename = "MR")]
3139 Mr,
3140 #[serde(rename = "MS")]
3141 Ms,
3142 #[serde(rename = "MT")]
3143 Mt,
3144 #[serde(rename = "MU")]
3145 Mu,
3146 #[serde(rename = "MV")]
3147 Mv,
3148 #[serde(rename = "MW")]
3149 Mw,
3150 #[serde(rename = "MX")]
3151 Mx,
3152 #[serde(rename = "MY")]
3153 My,
3154 #[serde(rename = "MZ")]
3155 Mz,
3156 #[serde(rename = "NA")]
3157 Na,
3158 #[serde(rename = "NC")]
3159 Nc,
3160 #[serde(rename = "NE")]
3161 Ne,
3162 #[serde(rename = "NF")]
3163 Nf,
3164 #[serde(rename = "NG")]
3165 Ng,
3166 #[serde(rename = "NI")]
3167 Ni,
3168 #[serde(rename = "NL")]
3169 Nl,
3170 #[serde(rename = "NO")]
3171 No,
3172 #[serde(rename = "NP")]
3173 Np,
3174 #[serde(rename = "NR")]
3175 Nr,
3176 #[serde(rename = "NU")]
3177 Nu,
3178 #[serde(rename = "NZ")]
3179 Nz,
3180 #[serde(rename = "OM")]
3181 Om,
3182 #[serde(rename = "PA")]
3183 Pa,
3184 #[serde(rename = "PE")]
3185 Pe,
3186 #[serde(rename = "PF")]
3187 Pf,
3188 #[serde(rename = "PG")]
3189 Pg,
3190 #[serde(rename = "PH")]
3191 Ph,
3192 #[serde(rename = "PK")]
3193 Pk,
3194 #[serde(rename = "PL")]
3195 Pl,
3196 #[serde(rename = "PM")]
3197 Pm,
3198 #[serde(rename = "PN")]
3199 Pn,
3200 #[serde(rename = "PR")]
3201 Pr,
3202 #[serde(rename = "PS")]
3203 Ps,
3204 #[serde(rename = "PT")]
3205 Pt,
3206 #[serde(rename = "PW")]
3207 Pw,
3208 #[serde(rename = "PY")]
3209 Py,
3210 #[serde(rename = "QA")]
3211 Qa,
3212 #[serde(rename = "RE")]
3213 Re,
3214 #[serde(rename = "RO")]
3215 Ro,
3216 #[serde(rename = "RS")]
3217 Rs,
3218 #[serde(rename = "RU")]
3219 Ru,
3220 #[serde(rename = "RW")]
3221 Rw,
3222 #[serde(rename = "SA")]
3223 Sa,
3224 #[serde(rename = "SB")]
3225 Sb,
3226 #[serde(rename = "SC")]
3227 Sc,
3228 #[serde(rename = "SE")]
3229 Se,
3230 #[serde(rename = "SG")]
3231 Sg,
3232 #[serde(rename = "SH")]
3233 Sh,
3234 #[serde(rename = "SI")]
3235 Si,
3236 #[serde(rename = "SJ")]
3237 Sj,
3238 #[serde(rename = "SK")]
3239 Sk,
3240 #[serde(rename = "SL")]
3241 Sl,
3242 #[serde(rename = "SM")]
3243 Sm,
3244 #[serde(rename = "SN")]
3245 Sn,
3246 #[serde(rename = "SO")]
3247 So,
3248 #[serde(rename = "SR")]
3249 Sr,
3250 #[serde(rename = "ST")]
3251 St,
3252 #[serde(rename = "SV")]
3253 Sv,
3254 #[serde(rename = "SX")]
3255 Sx,
3256 #[serde(rename = "SZ")]
3257 Sz,
3258 #[serde(rename = "TC")]
3259 Tc,
3260 #[serde(rename = "TD")]
3261 Td,
3262 #[serde(rename = "TF")]
3263 Tf,
3264 #[serde(rename = "TG")]
3265 Tg,
3266 #[serde(rename = "TH")]
3267 Th,
3268 #[serde(rename = "TJ")]
3269 Tj,
3270 #[serde(rename = "TK")]
3271 Tk,
3272 #[serde(rename = "TL")]
3273 Tl,
3274 #[serde(rename = "TM")]
3275 Tm,
3276 #[serde(rename = "TN")]
3277 Tn,
3278 #[serde(rename = "TO")]
3279 To,
3280 #[serde(rename = "TP")]
3281 Tp,
3282 #[serde(rename = "TR")]
3283 Tr,
3284 #[serde(rename = "TT")]
3285 Tt,
3286 #[serde(rename = "TV")]
3287 Tv,
3288 #[serde(rename = "TW")]
3289 Tw,
3290 #[serde(rename = "TZ")]
3291 Tz,
3292 #[serde(rename = "UA")]
3293 Ua,
3294 #[serde(rename = "UG")]
3295 Ug,
3296 #[serde(rename = "UM")]
3297 Um,
3298 #[serde(rename = "US")]
3299 Us,
3300 #[serde(rename = "UY")]
3301 Uy,
3302 #[serde(rename = "UZ")]
3303 Uz,
3304 #[serde(rename = "VA")]
3305 Va,
3306 #[serde(rename = "VC")]
3307 Vc,
3308 #[serde(rename = "VE")]
3309 Ve,
3310 #[serde(rename = "VG")]
3311 Vg,
3312 #[serde(rename = "VI")]
3313 Vi,
3314 #[serde(rename = "VN")]
3315 Vn,
3316 #[serde(rename = "VU")]
3317 Vu,
3318 #[serde(rename = "WF")]
3319 Wf,
3320 #[serde(rename = "WS")]
3321 Ws,
3322 #[serde(rename = "YE")]
3323 Ye,
3324 #[serde(rename = "YT")]
3325 Yt,
3326 #[serde(rename = "ZA")]
3327 Za,
3328 #[serde(rename = "ZM")]
3329 Zm,
3330 #[serde(rename = "ZW")]
3331 Zw,
3332}
3333impl std::fmt::Display for GetV1DomainsSuggestCountryEnum {
3334 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3335 let str_val = match self {
3336 GetV1DomainsSuggestCountryEnum::Ac => "AC",
3337 GetV1DomainsSuggestCountryEnum::Ad => "AD",
3338 GetV1DomainsSuggestCountryEnum::Ae => "AE",
3339 GetV1DomainsSuggestCountryEnum::Af => "AF",
3340 GetV1DomainsSuggestCountryEnum::Ag => "AG",
3341 GetV1DomainsSuggestCountryEnum::Ai => "AI",
3342 GetV1DomainsSuggestCountryEnum::Al => "AL",
3343 GetV1DomainsSuggestCountryEnum::Am => "AM",
3344 GetV1DomainsSuggestCountryEnum::Ao => "AO",
3345 GetV1DomainsSuggestCountryEnum::Aq => "AQ",
3346 GetV1DomainsSuggestCountryEnum::Ar => "AR",
3347 GetV1DomainsSuggestCountryEnum::As => "AS",
3348 GetV1DomainsSuggestCountryEnum::At => "AT",
3349 GetV1DomainsSuggestCountryEnum::Au => "AU",
3350 GetV1DomainsSuggestCountryEnum::Aw => "AW",
3351 GetV1DomainsSuggestCountryEnum::Ax => "AX",
3352 GetV1DomainsSuggestCountryEnum::Az => "AZ",
3353 GetV1DomainsSuggestCountryEnum::Ba => "BA",
3354 GetV1DomainsSuggestCountryEnum::Bb => "BB",
3355 GetV1DomainsSuggestCountryEnum::Bd => "BD",
3356 GetV1DomainsSuggestCountryEnum::Be => "BE",
3357 GetV1DomainsSuggestCountryEnum::Bf => "BF",
3358 GetV1DomainsSuggestCountryEnum::Bg => "BG",
3359 GetV1DomainsSuggestCountryEnum::Bh => "BH",
3360 GetV1DomainsSuggestCountryEnum::Bi => "BI",
3361 GetV1DomainsSuggestCountryEnum::Bj => "BJ",
3362 GetV1DomainsSuggestCountryEnum::Bm => "BM",
3363 GetV1DomainsSuggestCountryEnum::Bn => "BN",
3364 GetV1DomainsSuggestCountryEnum::Bo => "BO",
3365 GetV1DomainsSuggestCountryEnum::Bq => "BQ",
3366 GetV1DomainsSuggestCountryEnum::Br => "BR",
3367 GetV1DomainsSuggestCountryEnum::Bs => "BS",
3368 GetV1DomainsSuggestCountryEnum::Bt => "BT",
3369 GetV1DomainsSuggestCountryEnum::Bv => "BV",
3370 GetV1DomainsSuggestCountryEnum::Bw => "BW",
3371 GetV1DomainsSuggestCountryEnum::By => "BY",
3372 GetV1DomainsSuggestCountryEnum::Bz => "BZ",
3373 GetV1DomainsSuggestCountryEnum::Ca => "CA",
3374 GetV1DomainsSuggestCountryEnum::Cc => "CC",
3375 GetV1DomainsSuggestCountryEnum::Cd => "CD",
3376 GetV1DomainsSuggestCountryEnum::Cf => "CF",
3377 GetV1DomainsSuggestCountryEnum::Cg => "CG",
3378 GetV1DomainsSuggestCountryEnum::Ch => "CH",
3379 GetV1DomainsSuggestCountryEnum::Ci => "CI",
3380 GetV1DomainsSuggestCountryEnum::Ck => "CK",
3381 GetV1DomainsSuggestCountryEnum::Cl => "CL",
3382 GetV1DomainsSuggestCountryEnum::Cm => "CM",
3383 GetV1DomainsSuggestCountryEnum::Cn => "CN",
3384 GetV1DomainsSuggestCountryEnum::Co => "CO",
3385 GetV1DomainsSuggestCountryEnum::Cr => "CR",
3386 GetV1DomainsSuggestCountryEnum::Cv => "CV",
3387 GetV1DomainsSuggestCountryEnum::Cw => "CW",
3388 GetV1DomainsSuggestCountryEnum::Cx => "CX",
3389 GetV1DomainsSuggestCountryEnum::Cy => "CY",
3390 GetV1DomainsSuggestCountryEnum::Cz => "CZ",
3391 GetV1DomainsSuggestCountryEnum::De => "DE",
3392 GetV1DomainsSuggestCountryEnum::Dj => "DJ",
3393 GetV1DomainsSuggestCountryEnum::Dk => "DK",
3394 GetV1DomainsSuggestCountryEnum::Dm => "DM",
3395 GetV1DomainsSuggestCountryEnum::Do => "DO",
3396 GetV1DomainsSuggestCountryEnum::Dz => "DZ",
3397 GetV1DomainsSuggestCountryEnum::Ec => "EC",
3398 GetV1DomainsSuggestCountryEnum::Ee => "EE",
3399 GetV1DomainsSuggestCountryEnum::Eg => "EG",
3400 GetV1DomainsSuggestCountryEnum::Eh => "EH",
3401 GetV1DomainsSuggestCountryEnum::Er => "ER",
3402 GetV1DomainsSuggestCountryEnum::Es => "ES",
3403 GetV1DomainsSuggestCountryEnum::Et => "ET",
3404 GetV1DomainsSuggestCountryEnum::Fi => "FI",
3405 GetV1DomainsSuggestCountryEnum::Fj => "FJ",
3406 GetV1DomainsSuggestCountryEnum::Fk => "FK",
3407 GetV1DomainsSuggestCountryEnum::Fm => "FM",
3408 GetV1DomainsSuggestCountryEnum::Fo => "FO",
3409 GetV1DomainsSuggestCountryEnum::Fr => "FR",
3410 GetV1DomainsSuggestCountryEnum::Ga => "GA",
3411 GetV1DomainsSuggestCountryEnum::Gb => "GB",
3412 GetV1DomainsSuggestCountryEnum::Gd => "GD",
3413 GetV1DomainsSuggestCountryEnum::Ge => "GE",
3414 GetV1DomainsSuggestCountryEnum::Gf => "GF",
3415 GetV1DomainsSuggestCountryEnum::Gg => "GG",
3416 GetV1DomainsSuggestCountryEnum::Gh => "GH",
3417 GetV1DomainsSuggestCountryEnum::Gi => "GI",
3418 GetV1DomainsSuggestCountryEnum::Gl => "GL",
3419 GetV1DomainsSuggestCountryEnum::Gm => "GM",
3420 GetV1DomainsSuggestCountryEnum::Gn => "GN",
3421 GetV1DomainsSuggestCountryEnum::Gp => "GP",
3422 GetV1DomainsSuggestCountryEnum::Gq => "GQ",
3423 GetV1DomainsSuggestCountryEnum::Gr => "GR",
3424 GetV1DomainsSuggestCountryEnum::Gs => "GS",
3425 GetV1DomainsSuggestCountryEnum::Gt => "GT",
3426 GetV1DomainsSuggestCountryEnum::Gu => "GU",
3427 GetV1DomainsSuggestCountryEnum::Gw => "GW",
3428 GetV1DomainsSuggestCountryEnum::Gy => "GY",
3429 GetV1DomainsSuggestCountryEnum::Hk => "HK",
3430 GetV1DomainsSuggestCountryEnum::Hm => "HM",
3431 GetV1DomainsSuggestCountryEnum::Hn => "HN",
3432 GetV1DomainsSuggestCountryEnum::Hr => "HR",
3433 GetV1DomainsSuggestCountryEnum::Ht => "HT",
3434 GetV1DomainsSuggestCountryEnum::Hu => "HU",
3435 GetV1DomainsSuggestCountryEnum::Id => "ID",
3436 GetV1DomainsSuggestCountryEnum::Ie => "IE",
3437 GetV1DomainsSuggestCountryEnum::Il => "IL",
3438 GetV1DomainsSuggestCountryEnum::Im => "IM",
3439 GetV1DomainsSuggestCountryEnum::In => "IN",
3440 GetV1DomainsSuggestCountryEnum::Io => "IO",
3441 GetV1DomainsSuggestCountryEnum::Iq => "IQ",
3442 GetV1DomainsSuggestCountryEnum::Is => "IS",
3443 GetV1DomainsSuggestCountryEnum::It => "IT",
3444 GetV1DomainsSuggestCountryEnum::Je => "JE",
3445 GetV1DomainsSuggestCountryEnum::Jm => "JM",
3446 GetV1DomainsSuggestCountryEnum::Jo => "JO",
3447 GetV1DomainsSuggestCountryEnum::Jp => "JP",
3448 GetV1DomainsSuggestCountryEnum::Ke => "KE",
3449 GetV1DomainsSuggestCountryEnum::Kg => "KG",
3450 GetV1DomainsSuggestCountryEnum::Kh => "KH",
3451 GetV1DomainsSuggestCountryEnum::Ki => "KI",
3452 GetV1DomainsSuggestCountryEnum::Km => "KM",
3453 GetV1DomainsSuggestCountryEnum::Kn => "KN",
3454 GetV1DomainsSuggestCountryEnum::Kr => "KR",
3455 GetV1DomainsSuggestCountryEnum::Kv => "KV",
3456 GetV1DomainsSuggestCountryEnum::Kw => "KW",
3457 GetV1DomainsSuggestCountryEnum::Ky => "KY",
3458 GetV1DomainsSuggestCountryEnum::Kz => "KZ",
3459 GetV1DomainsSuggestCountryEnum::La => "LA",
3460 GetV1DomainsSuggestCountryEnum::Lb => "LB",
3461 GetV1DomainsSuggestCountryEnum::Lc => "LC",
3462 GetV1DomainsSuggestCountryEnum::Li => "LI",
3463 GetV1DomainsSuggestCountryEnum::Lk => "LK",
3464 GetV1DomainsSuggestCountryEnum::Lr => "LR",
3465 GetV1DomainsSuggestCountryEnum::Ls => "LS",
3466 GetV1DomainsSuggestCountryEnum::Lt => "LT",
3467 GetV1DomainsSuggestCountryEnum::Lu => "LU",
3468 GetV1DomainsSuggestCountryEnum::Lv => "LV",
3469 GetV1DomainsSuggestCountryEnum::Ly => "LY",
3470 GetV1DomainsSuggestCountryEnum::Ma => "MA",
3471 GetV1DomainsSuggestCountryEnum::Mc => "MC",
3472 GetV1DomainsSuggestCountryEnum::Md => "MD",
3473 GetV1DomainsSuggestCountryEnum::Me => "ME",
3474 GetV1DomainsSuggestCountryEnum::Mg => "MG",
3475 GetV1DomainsSuggestCountryEnum::Mh => "MH",
3476 GetV1DomainsSuggestCountryEnum::Mk => "MK",
3477 GetV1DomainsSuggestCountryEnum::Ml => "ML",
3478 GetV1DomainsSuggestCountryEnum::Mm => "MM",
3479 GetV1DomainsSuggestCountryEnum::Mn => "MN",
3480 GetV1DomainsSuggestCountryEnum::Mo => "MO",
3481 GetV1DomainsSuggestCountryEnum::Mp => "MP",
3482 GetV1DomainsSuggestCountryEnum::Mq => "MQ",
3483 GetV1DomainsSuggestCountryEnum::Mr => "MR",
3484 GetV1DomainsSuggestCountryEnum::Ms => "MS",
3485 GetV1DomainsSuggestCountryEnum::Mt => "MT",
3486 GetV1DomainsSuggestCountryEnum::Mu => "MU",
3487 GetV1DomainsSuggestCountryEnum::Mv => "MV",
3488 GetV1DomainsSuggestCountryEnum::Mw => "MW",
3489 GetV1DomainsSuggestCountryEnum::Mx => "MX",
3490 GetV1DomainsSuggestCountryEnum::My => "MY",
3491 GetV1DomainsSuggestCountryEnum::Mz => "MZ",
3492 GetV1DomainsSuggestCountryEnum::Na => "NA",
3493 GetV1DomainsSuggestCountryEnum::Nc => "NC",
3494 GetV1DomainsSuggestCountryEnum::Ne => "NE",
3495 GetV1DomainsSuggestCountryEnum::Nf => "NF",
3496 GetV1DomainsSuggestCountryEnum::Ng => "NG",
3497 GetV1DomainsSuggestCountryEnum::Ni => "NI",
3498 GetV1DomainsSuggestCountryEnum::Nl => "NL",
3499 GetV1DomainsSuggestCountryEnum::No => "NO",
3500 GetV1DomainsSuggestCountryEnum::Np => "NP",
3501 GetV1DomainsSuggestCountryEnum::Nr => "NR",
3502 GetV1DomainsSuggestCountryEnum::Nu => "NU",
3503 GetV1DomainsSuggestCountryEnum::Nz => "NZ",
3504 GetV1DomainsSuggestCountryEnum::Om => "OM",
3505 GetV1DomainsSuggestCountryEnum::Pa => "PA",
3506 GetV1DomainsSuggestCountryEnum::Pe => "PE",
3507 GetV1DomainsSuggestCountryEnum::Pf => "PF",
3508 GetV1DomainsSuggestCountryEnum::Pg => "PG",
3509 GetV1DomainsSuggestCountryEnum::Ph => "PH",
3510 GetV1DomainsSuggestCountryEnum::Pk => "PK",
3511 GetV1DomainsSuggestCountryEnum::Pl => "PL",
3512 GetV1DomainsSuggestCountryEnum::Pm => "PM",
3513 GetV1DomainsSuggestCountryEnum::Pn => "PN",
3514 GetV1DomainsSuggestCountryEnum::Pr => "PR",
3515 GetV1DomainsSuggestCountryEnum::Ps => "PS",
3516 GetV1DomainsSuggestCountryEnum::Pt => "PT",
3517 GetV1DomainsSuggestCountryEnum::Pw => "PW",
3518 GetV1DomainsSuggestCountryEnum::Py => "PY",
3519 GetV1DomainsSuggestCountryEnum::Qa => "QA",
3520 GetV1DomainsSuggestCountryEnum::Re => "RE",
3521 GetV1DomainsSuggestCountryEnum::Ro => "RO",
3522 GetV1DomainsSuggestCountryEnum::Rs => "RS",
3523 GetV1DomainsSuggestCountryEnum::Ru => "RU",
3524 GetV1DomainsSuggestCountryEnum::Rw => "RW",
3525 GetV1DomainsSuggestCountryEnum::Sa => "SA",
3526 GetV1DomainsSuggestCountryEnum::Sb => "SB",
3527 GetV1DomainsSuggestCountryEnum::Sc => "SC",
3528 GetV1DomainsSuggestCountryEnum::Se => "SE",
3529 GetV1DomainsSuggestCountryEnum::Sg => "SG",
3530 GetV1DomainsSuggestCountryEnum::Sh => "SH",
3531 GetV1DomainsSuggestCountryEnum::Si => "SI",
3532 GetV1DomainsSuggestCountryEnum::Sj => "SJ",
3533 GetV1DomainsSuggestCountryEnum::Sk => "SK",
3534 GetV1DomainsSuggestCountryEnum::Sl => "SL",
3535 GetV1DomainsSuggestCountryEnum::Sm => "SM",
3536 GetV1DomainsSuggestCountryEnum::Sn => "SN",
3537 GetV1DomainsSuggestCountryEnum::So => "SO",
3538 GetV1DomainsSuggestCountryEnum::Sr => "SR",
3539 GetV1DomainsSuggestCountryEnum::St => "ST",
3540 GetV1DomainsSuggestCountryEnum::Sv => "SV",
3541 GetV1DomainsSuggestCountryEnum::Sx => "SX",
3542 GetV1DomainsSuggestCountryEnum::Sz => "SZ",
3543 GetV1DomainsSuggestCountryEnum::Tc => "TC",
3544 GetV1DomainsSuggestCountryEnum::Td => "TD",
3545 GetV1DomainsSuggestCountryEnum::Tf => "TF",
3546 GetV1DomainsSuggestCountryEnum::Tg => "TG",
3547 GetV1DomainsSuggestCountryEnum::Th => "TH",
3548 GetV1DomainsSuggestCountryEnum::Tj => "TJ",
3549 GetV1DomainsSuggestCountryEnum::Tk => "TK",
3550 GetV1DomainsSuggestCountryEnum::Tl => "TL",
3551 GetV1DomainsSuggestCountryEnum::Tm => "TM",
3552 GetV1DomainsSuggestCountryEnum::Tn => "TN",
3553 GetV1DomainsSuggestCountryEnum::To => "TO",
3554 GetV1DomainsSuggestCountryEnum::Tp => "TP",
3555 GetV1DomainsSuggestCountryEnum::Tr => "TR",
3556 GetV1DomainsSuggestCountryEnum::Tt => "TT",
3557 GetV1DomainsSuggestCountryEnum::Tv => "TV",
3558 GetV1DomainsSuggestCountryEnum::Tw => "TW",
3559 GetV1DomainsSuggestCountryEnum::Tz => "TZ",
3560 GetV1DomainsSuggestCountryEnum::Ua => "UA",
3561 GetV1DomainsSuggestCountryEnum::Ug => "UG",
3562 GetV1DomainsSuggestCountryEnum::Um => "UM",
3563 GetV1DomainsSuggestCountryEnum::Us => "US",
3564 GetV1DomainsSuggestCountryEnum::Uy => "UY",
3565 GetV1DomainsSuggestCountryEnum::Uz => "UZ",
3566 GetV1DomainsSuggestCountryEnum::Va => "VA",
3567 GetV1DomainsSuggestCountryEnum::Vc => "VC",
3568 GetV1DomainsSuggestCountryEnum::Ve => "VE",
3569 GetV1DomainsSuggestCountryEnum::Vg => "VG",
3570 GetV1DomainsSuggestCountryEnum::Vi => "VI",
3571 GetV1DomainsSuggestCountryEnum::Vn => "VN",
3572 GetV1DomainsSuggestCountryEnum::Vu => "VU",
3573 GetV1DomainsSuggestCountryEnum::Wf => "WF",
3574 GetV1DomainsSuggestCountryEnum::Ws => "WS",
3575 GetV1DomainsSuggestCountryEnum::Ye => "YE",
3576 GetV1DomainsSuggestCountryEnum::Yt => "YT",
3577 GetV1DomainsSuggestCountryEnum::Za => "ZA",
3578 GetV1DomainsSuggestCountryEnum::Zm => "ZM",
3579 GetV1DomainsSuggestCountryEnum::Zw => "ZW",
3580 };
3581 write!(f, "{}", str_val)
3582 }
3583}
3584#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3585pub enum GetV1DomainsSuggestSourcesItemEnum {
3586 #[default]
3587 #[serde(rename = "CC_TLD")]
3588 CcTld,
3589 #[serde(rename = "EXTENSION")]
3590 Extension,
3591 #[serde(rename = "KEYWORD_SPIN")]
3592 KeywordSpin,
3593 #[serde(rename = "PREMIUM")]
3594 Premium,
3595 #[serde(rename = "cctld")]
3596 Cctld,
3597 #[serde(rename = "keywordspin")]
3598 Keywordspin,
3599}
3600impl std::fmt::Display for GetV1DomainsSuggestSourcesItemEnum {
3601 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3602 let str_val = match self {
3603 GetV1DomainsSuggestSourcesItemEnum::CcTld => "CC_TLD",
3604 GetV1DomainsSuggestSourcesItemEnum::Extension => "EXTENSION",
3605 GetV1DomainsSuggestSourcesItemEnum::KeywordSpin => "KEYWORD_SPIN",
3606 GetV1DomainsSuggestSourcesItemEnum::Premium => "PREMIUM",
3607 GetV1DomainsSuggestSourcesItemEnum::Cctld => "cctld",
3608 GetV1DomainsSuggestSourcesItemEnum::Keywordspin => "keywordspin",
3609 };
3610 write!(f, "{}", str_val)
3611 }
3612}
3613#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3614pub enum TldSummaryTypeEnum {
3615 #[default]
3616 #[serde(rename = "COUNTRY_CODE")]
3617 CountryCode,
3618 #[serde(rename = "GENERIC")]
3619 Generic,
3620}
3621impl std::fmt::Display for TldSummaryTypeEnum {
3622 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3623 let str_val = match self {
3624 TldSummaryTypeEnum::CountryCode => "COUNTRY_CODE",
3625 TldSummaryTypeEnum::Generic => "GENERIC",
3626 };
3627 write!(f, "{}", str_val)
3628 }
3629}
3630#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3631pub enum VerificationDomainNameStatusEnum {
3632 #[default]
3633 #[serde(rename = "APPROVED")]
3634 Approved,
3635 #[serde(rename = "PENDING")]
3636 Pending,
3637 #[serde(rename = "REJECTED")]
3638 Rejected,
3639 #[serde(rename = "UNABLE_TO_RETRIEVE_STATUS")]
3640 UnableToRetrieveStatus,
3641}
3642impl std::fmt::Display for VerificationDomainNameStatusEnum {
3643 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3644 let str_val = match self {
3645 VerificationDomainNameStatusEnum::Approved => "APPROVED",
3646 VerificationDomainNameStatusEnum::Pending => "PENDING",
3647 VerificationDomainNameStatusEnum::Rejected => "REJECTED",
3648 VerificationDomainNameStatusEnum::UnableToRetrieveStatus => "UNABLE_TO_RETRIEVE_STATUS",
3649 };
3650 write!(f, "{}", str_val)
3651 }
3652}
3653#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3654pub enum VerificationRealNameStatusEnum {
3655 #[default]
3656 #[serde(rename = "APPROVED")]
3657 Approved,
3658 #[serde(rename = "PENDING")]
3659 Pending,
3660 #[serde(rename = "REJECTED_DOCUMENT_OUTDATED")]
3661 RejectedDocumentOutdated,
3662 #[serde(rename = "REJECTED_EXPIRED_BUSINESS_LICENSE")]
3663 RejectedExpiredBusinessLicense,
3664 #[serde(rename = "REJECTED_EXPIRED_ORGANIZATION_CODE")]
3665 RejectedExpiredOrganizationCode,
3666 #[serde(rename = "REJECTED_ILLEGIBLE_DOCUMENT_NAME")]
3667 RejectedIllegibleDocumentName,
3668 #[serde(rename = "REJECTED_ILLEGIBLE_IDENTIFICATION")]
3669 RejectedIllegibleIdentification,
3670 #[serde(rename = "REJECTED_INCOMPLETE_IDENTIFICATION")]
3671 RejectedIncompleteIdentification,
3672 #[serde(rename = "REJECTED_INCOMPLETE_REGISTRATION_LETTER")]
3673 RejectedIncompleteRegistrationLetter,
3674 #[serde(rename = "REJECTED_INCONSISTENT_IDENTITY_CARD")]
3675 RejectedInconsistentIdentityCard,
3676 #[serde(rename = "REJECTED_INCONSISTENT_ORGANIZATION_CODE")]
3677 RejectedInconsistentOrganizationCode,
3678 #[serde(rename = "REJECTED_INCONSISTENT_REGISTRANT_NAME")]
3679 RejectedInconsistentRegistrantName,
3680 #[serde(rename = "REJECTED_INVALID_BUSINESS_LICENSE_OR_ORGANIZATION_CODE")]
3681 RejectedInvalidBusinessLicenseOrOrganizationCode,
3682 #[serde(rename = "REJECTED_INVALID_DOCUMENT")]
3683 RejectedInvalidDocument,
3684 #[serde(rename = "REJECTED_MISMATCH_BUSINESS_ID")]
3685 RejectedMismatchBusinessId,
3686 #[serde(rename = "REJECTED_MISMATCH_BUSINESS_NAME")]
3687 RejectedMismatchBusinessName,
3688 #[serde(rename = "REJECTED_MISMATCH_DOCUMENT_ID")]
3689 RejectedMismatchDocumentId,
3690 #[serde(rename = "REJECTED_MISMATCH_DOCUMENT_NAME")]
3691 RejectedMismatchDocumentName,
3692 #[serde(rename = "REJECTED_MISMATCH_DOCUMENT_TYPE")]
3693 RejectedMismatchDocumentType,
3694 #[serde(rename = "REJECTED_MISMATCH_REGISTRANT_INFO")]
3695 RejectedMismatchRegistrantInfo,
3696 #[serde(rename = "REJECTED_MISMATCH_REGISTRANT_LOCALITY")]
3697 RejectedMismatchRegistrantLocality,
3698 #[serde(rename = "REJECTED_MISMATCH_REGISTRANT_NAME")]
3699 RejectedMismatchRegistrantName,
3700 #[serde(rename = "REJECTED_UNABLE_TO_OPEN")]
3701 RejectedUnableToOpen,
3702 #[serde(rename = "REJECTED_UNABLE_TO_VERIFY")]
3703 RejectedUnableToVerify,
3704 #[serde(rename = "REJECTED_UNKNOWN_ERROR")]
3705 RejectedUnknownError,
3706 #[serde(rename = "UNABLE_TO_RETRIEVE_STATUS")]
3707 UnableToRetrieveStatus,
3708}
3709impl std::fmt::Display for VerificationRealNameStatusEnum {
3710 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3711 let str_val = match self {
3712 VerificationRealNameStatusEnum::Approved => "APPROVED",
3713 VerificationRealNameStatusEnum::Pending => "PENDING",
3714 VerificationRealNameStatusEnum::RejectedDocumentOutdated => {
3715 "REJECTED_DOCUMENT_OUTDATED"
3716 }
3717 VerificationRealNameStatusEnum::RejectedExpiredBusinessLicense => {
3718 "REJECTED_EXPIRED_BUSINESS_LICENSE"
3719 }
3720 VerificationRealNameStatusEnum::RejectedExpiredOrganizationCode => {
3721 "REJECTED_EXPIRED_ORGANIZATION_CODE"
3722 }
3723 VerificationRealNameStatusEnum::RejectedIllegibleDocumentName => {
3724 "REJECTED_ILLEGIBLE_DOCUMENT_NAME"
3725 }
3726 VerificationRealNameStatusEnum::RejectedIllegibleIdentification => {
3727 "REJECTED_ILLEGIBLE_IDENTIFICATION"
3728 }
3729 VerificationRealNameStatusEnum::RejectedIncompleteIdentification => {
3730 "REJECTED_INCOMPLETE_IDENTIFICATION"
3731 }
3732 VerificationRealNameStatusEnum::RejectedIncompleteRegistrationLetter => {
3733 "REJECTED_INCOMPLETE_REGISTRATION_LETTER"
3734 }
3735 VerificationRealNameStatusEnum::RejectedInconsistentIdentityCard => {
3736 "REJECTED_INCONSISTENT_IDENTITY_CARD"
3737 }
3738 VerificationRealNameStatusEnum::RejectedInconsistentOrganizationCode => {
3739 "REJECTED_INCONSISTENT_ORGANIZATION_CODE"
3740 }
3741 VerificationRealNameStatusEnum::RejectedInconsistentRegistrantName => {
3742 "REJECTED_INCONSISTENT_REGISTRANT_NAME"
3743 }
3744 VerificationRealNameStatusEnum::RejectedInvalidBusinessLicenseOrOrganizationCode => {
3745 "REJECTED_INVALID_BUSINESS_LICENSE_OR_ORGANIZATION_CODE"
3746 }
3747 VerificationRealNameStatusEnum::RejectedInvalidDocument => "REJECTED_INVALID_DOCUMENT",
3748 VerificationRealNameStatusEnum::RejectedMismatchBusinessId => {
3749 "REJECTED_MISMATCH_BUSINESS_ID"
3750 }
3751 VerificationRealNameStatusEnum::RejectedMismatchBusinessName => {
3752 "REJECTED_MISMATCH_BUSINESS_NAME"
3753 }
3754 VerificationRealNameStatusEnum::RejectedMismatchDocumentId => {
3755 "REJECTED_MISMATCH_DOCUMENT_ID"
3756 }
3757 VerificationRealNameStatusEnum::RejectedMismatchDocumentName => {
3758 "REJECTED_MISMATCH_DOCUMENT_NAME"
3759 }
3760 VerificationRealNameStatusEnum::RejectedMismatchDocumentType => {
3761 "REJECTED_MISMATCH_DOCUMENT_TYPE"
3762 }
3763 VerificationRealNameStatusEnum::RejectedMismatchRegistrantInfo => {
3764 "REJECTED_MISMATCH_REGISTRANT_INFO"
3765 }
3766 VerificationRealNameStatusEnum::RejectedMismatchRegistrantLocality => {
3767 "REJECTED_MISMATCH_REGISTRANT_LOCALITY"
3768 }
3769 VerificationRealNameStatusEnum::RejectedMismatchRegistrantName => {
3770 "REJECTED_MISMATCH_REGISTRANT_NAME"
3771 }
3772 VerificationRealNameStatusEnum::RejectedUnableToOpen => "REJECTED_UNABLE_TO_OPEN",
3773 VerificationRealNameStatusEnum::RejectedUnableToVerify => "REJECTED_UNABLE_TO_VERIFY",
3774 VerificationRealNameStatusEnum::RejectedUnknownError => "REJECTED_UNKNOWN_ERROR",
3775 VerificationRealNameStatusEnum::UnableToRetrieveStatus => "UNABLE_TO_RETRIEVE_STATUS",
3776 };
3777 write!(f, "{}", str_val)
3778 }
3779}
3780#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3781pub enum GetV1DomainsDomainRecordsTypeNameTypeEnum {
3782 #[default]
3783 #[serde(rename = "A")]
3784 A,
3785 #[serde(rename = "AAAA")]
3786 Aaaa,
3787 #[serde(rename = "CNAME")]
3788 Cname,
3789 #[serde(rename = "MX")]
3790 Mx,
3791 #[serde(rename = "NS")]
3792 Ns,
3793 #[serde(rename = "SOA")]
3794 Soa,
3795 #[serde(rename = "SRV")]
3796 Srv,
3797 #[serde(rename = "TXT")]
3798 Txt,
3799}
3800impl std::fmt::Display for GetV1DomainsDomainRecordsTypeNameTypeEnum {
3801 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3802 let str_val = match self {
3803 GetV1DomainsDomainRecordsTypeNameTypeEnum::A => "A",
3804 GetV1DomainsDomainRecordsTypeNameTypeEnum::Aaaa => "AAAA",
3805 GetV1DomainsDomainRecordsTypeNameTypeEnum::Cname => "CNAME",
3806 GetV1DomainsDomainRecordsTypeNameTypeEnum::Mx => "MX",
3807 GetV1DomainsDomainRecordsTypeNameTypeEnum::Ns => "NS",
3808 GetV1DomainsDomainRecordsTypeNameTypeEnum::Soa => "SOA",
3809 GetV1DomainsDomainRecordsTypeNameTypeEnum::Srv => "SRV",
3810 GetV1DomainsDomainRecordsTypeNameTypeEnum::Txt => "TXT",
3811 };
3812 write!(f, "{}", str_val)
3813 }
3814}
3815#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3816pub enum DnsRecordTypeEnum {
3817 #[default]
3818 #[serde(rename = "A")]
3819 A,
3820 #[serde(rename = "AAAA")]
3821 Aaaa,
3822 #[serde(rename = "CNAME")]
3823 Cname,
3824 #[serde(rename = "MX")]
3825 Mx,
3826 #[serde(rename = "NS")]
3827 Ns,
3828 #[serde(rename = "SOA")]
3829 Soa,
3830 #[serde(rename = "SRV")]
3831 Srv,
3832 #[serde(rename = "TXT")]
3833 Txt,
3834}
3835impl std::fmt::Display for DnsRecordTypeEnum {
3836 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3837 let str_val = match self {
3838 DnsRecordTypeEnum::A => "A",
3839 DnsRecordTypeEnum::Aaaa => "AAAA",
3840 DnsRecordTypeEnum::Cname => "CNAME",
3841 DnsRecordTypeEnum::Mx => "MX",
3842 DnsRecordTypeEnum::Ns => "NS",
3843 DnsRecordTypeEnum::Soa => "SOA",
3844 DnsRecordTypeEnum::Srv => "SRV",
3845 DnsRecordTypeEnum::Txt => "TXT",
3846 };
3847 write!(f, "{}", str_val)
3848 }
3849}
3850#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3851pub enum DomainForwardingTypeEnum {
3852 #[default]
3853 #[serde(rename = "MASKED")]
3854 Masked,
3855 #[serde(rename = "REDIRECT_PERMANENT")]
3856 RedirectPermanent,
3857 #[serde(rename = "REDIRECT_TEMPORARY")]
3858 RedirectTemporary,
3859}
3860impl std::fmt::Display for DomainForwardingTypeEnum {
3861 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3862 let str_val = match self {
3863 DomainForwardingTypeEnum::Masked => "MASKED",
3864 DomainForwardingTypeEnum::RedirectPermanent => "REDIRECT_PERMANENT",
3865 DomainForwardingTypeEnum::RedirectTemporary => "REDIRECT_TEMPORARY",
3866 };
3867 write!(f, "{}", str_val)
3868 }
3869}
3870#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3871pub enum DomainNotificationResourceTypeEnum {
3872 #[default]
3873 #[serde(rename = "CONTACT")]
3874 Contact,
3875 #[serde(rename = "DOMAIN")]
3876 Domain,
3877 #[serde(rename = "HOST")]
3878 Host,
3879}
3880impl std::fmt::Display for DomainNotificationResourceTypeEnum {
3881 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3882 let str_val = match self {
3883 DomainNotificationResourceTypeEnum::Contact => "CONTACT",
3884 DomainNotificationResourceTypeEnum::Domain => "DOMAIN",
3885 DomainNotificationResourceTypeEnum::Host => "HOST",
3886 };
3887 write!(f, "{}", str_val)
3888 }
3889}
3890#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3891pub enum DomainNotificationStatusEnum {
3892 #[default]
3893 #[serde(rename = "AWAITING")]
3894 Awaiting,
3895 #[serde(rename = "CANCELLED")]
3896 Cancelled,
3897 #[serde(rename = "FAILED")]
3898 Failed,
3899 #[serde(rename = "PENDING")]
3900 Pending,
3901 #[serde(rename = "SUCCESS")]
3902 Success,
3903}
3904impl std::fmt::Display for DomainNotificationStatusEnum {
3905 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3906 let str_val = match self {
3907 DomainNotificationStatusEnum::Awaiting => "AWAITING",
3908 DomainNotificationStatusEnum::Cancelled => "CANCELLED",
3909 DomainNotificationStatusEnum::Failed => "FAILED",
3910 DomainNotificationStatusEnum::Pending => "PENDING",
3911 DomainNotificationStatusEnum::Success => "SUCCESS",
3912 };
3913 write!(f, "{}", str_val)
3914 }
3915}
3916#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
3917pub enum DomainNotificationTypeEnum {
3918 #[default]
3919 #[serde(rename = "AUTH_CODE_PURCHASE")]
3920 AuthCodePurchase,
3921 #[serde(rename = "AUTH_CODE_REGENERATE")]
3922 AuthCodeRegenerate,
3923 #[serde(rename = "AUTO_RENEWAL")]
3924 AutoRenewal,
3925 #[serde(rename = "BACKORDER")]
3926 Backorder,
3927 #[serde(rename = "BACKORDER_PURCHASE")]
3928 BackorderPurchase,
3929 #[serde(rename = "BACKORDER_DELETE")]
3930 BackorderDelete,
3931 #[serde(rename = "BACKORDER_UPDATE")]
3932 BackorderUpdate,
3933 #[serde(rename = "CHANGE_OF_REGISTRANT_DELETE")]
3934 ChangeOfRegistrantDelete,
3935 #[serde(rename = "CONTACT_CREATE")]
3936 ContactCreate,
3937 #[serde(rename = "CONTACT_DELETE")]
3938 ContactDelete,
3939 #[serde(rename = "CONTACT_UPDATE")]
3940 ContactUpdate,
3941 #[serde(rename = "DNS_VERIFICATION")]
3942 DnsVerification,
3943 #[serde(rename = "DNSSEC_CREATE")]
3944 DnssecCreate,
3945 #[serde(rename = "DNSSEC_DELETE")]
3946 DnssecDelete,
3947 #[serde(rename = "DOMAIN_DELETE")]
3948 DomainDelete,
3949 #[serde(rename = "DOMAIN_UPDATE")]
3950 DomainUpdate,
3951 #[serde(rename = "DOMAIN_UPDATE_CONTACTS")]
3952 DomainUpdateContacts,
3953 #[serde(rename = "DOMAIN_UPDATE_NAME_SERVERS")]
3954 DomainUpdateNameServers,
3955 #[serde(rename = "EXPIRY")]
3956 Expiry,
3957 #[serde(rename = "HOST_CREATE")]
3958 HostCreate,
3959 #[serde(rename = "HOST_DELETE")]
3960 HostDelete,
3961 #[serde(rename = "ICANN_VERIFICATION")]
3962 IcannVerification,
3963 #[serde(rename = "MIGRATE")]
3964 Migrate,
3965 #[serde(rename = "MIGRATE_IN")]
3966 MigrateIn,
3967 #[serde(rename = "PREMIUM")]
3968 Premium,
3969 #[serde(rename = "PRIVACY_FORWARDING_UPDATE")]
3970 PrivacyForwardingUpdate,
3971 #[serde(rename = "PRIVACY_PURCHASE")]
3972 PrivacyPurchase,
3973 #[serde(rename = "PRIVACY_DELETE")]
3974 PrivacyDelete,
3975 #[serde(rename = "REDEEM")]
3976 Redeem,
3977 #[serde(rename = "REGISTER")]
3978 Register,
3979 #[serde(rename = "RENEW")]
3980 Renew,
3981 #[serde(rename = "RENEW_UNDO")]
3982 RenewUndo,
3983 #[serde(rename = "TRADE")]
3984 Trade,
3985 #[serde(rename = "TRADE_CANCEL")]
3986 TradeCancel,
3987 #[serde(rename = "TRADE_PURCHASE")]
3988 TradePurchase,
3989 #[serde(rename = "TRADE_PURCHASE_AUTH_TEXT_MESSAGE")]
3990 TradePurchaseAuthTextMessage,
3991 #[serde(rename = "TRADE_RESEND_AUTH_EMAIL")]
3992 TradeResendAuthEmail,
3993 #[serde(rename = "TRANSFER")]
3994 Transfer,
3995 #[serde(rename = "TRANSFER_IN")]
3996 TransferIn,
3997 #[serde(rename = "TRANSFER_IN_ACCEPT")]
3998 TransferInAccept,
3999 #[serde(rename = "TRANSFER_IN_CANCEL")]
4000 TransferInCancel,
4001 #[serde(rename = "TRANSFER_IN_RESTART")]
4002 TransferInRestart,
4003 #[serde(rename = "TRANSFER_IN_RETRY")]
4004 TransferInRetry,
4005 #[serde(rename = "TRANSFER_OUT")]
4006 TransferOut,
4007 #[serde(rename = "TRANSFER_OUT_ACCEPT")]
4008 TransferOutAccept,
4009 #[serde(rename = "TRANSFER_OUT_REJECT")]
4010 TransferOutReject,
4011 #[serde(rename = "TRANSFER_OUT_REQUESTED")]
4012 TransferOutRequested,
4013 #[serde(rename = "TRANSIT")]
4014 Transit,
4015}
4016impl std::fmt::Display for DomainNotificationTypeEnum {
4017 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4018 let str_val = match self {
4019 DomainNotificationTypeEnum::AuthCodePurchase => "AUTH_CODE_PURCHASE",
4020 DomainNotificationTypeEnum::AuthCodeRegenerate => "AUTH_CODE_REGENERATE",
4021 DomainNotificationTypeEnum::AutoRenewal => "AUTO_RENEWAL",
4022 DomainNotificationTypeEnum::Backorder => "BACKORDER",
4023 DomainNotificationTypeEnum::BackorderPurchase => "BACKORDER_PURCHASE",
4024 DomainNotificationTypeEnum::BackorderDelete => "BACKORDER_DELETE",
4025 DomainNotificationTypeEnum::BackorderUpdate => "BACKORDER_UPDATE",
4026 DomainNotificationTypeEnum::ChangeOfRegistrantDelete => "CHANGE_OF_REGISTRANT_DELETE",
4027 DomainNotificationTypeEnum::ContactCreate => "CONTACT_CREATE",
4028 DomainNotificationTypeEnum::ContactDelete => "CONTACT_DELETE",
4029 DomainNotificationTypeEnum::ContactUpdate => "CONTACT_UPDATE",
4030 DomainNotificationTypeEnum::DnsVerification => "DNS_VERIFICATION",
4031 DomainNotificationTypeEnum::DnssecCreate => "DNSSEC_CREATE",
4032 DomainNotificationTypeEnum::DnssecDelete => "DNSSEC_DELETE",
4033 DomainNotificationTypeEnum::DomainDelete => "DOMAIN_DELETE",
4034 DomainNotificationTypeEnum::DomainUpdate => "DOMAIN_UPDATE",
4035 DomainNotificationTypeEnum::DomainUpdateContacts => "DOMAIN_UPDATE_CONTACTS",
4036 DomainNotificationTypeEnum::DomainUpdateNameServers => "DOMAIN_UPDATE_NAME_SERVERS",
4037 DomainNotificationTypeEnum::Expiry => "EXPIRY",
4038 DomainNotificationTypeEnum::HostCreate => "HOST_CREATE",
4039 DomainNotificationTypeEnum::HostDelete => "HOST_DELETE",
4040 DomainNotificationTypeEnum::IcannVerification => "ICANN_VERIFICATION",
4041 DomainNotificationTypeEnum::Migrate => "MIGRATE",
4042 DomainNotificationTypeEnum::MigrateIn => "MIGRATE_IN",
4043 DomainNotificationTypeEnum::Premium => "PREMIUM",
4044 DomainNotificationTypeEnum::PrivacyForwardingUpdate => "PRIVACY_FORWARDING_UPDATE",
4045 DomainNotificationTypeEnum::PrivacyPurchase => "PRIVACY_PURCHASE",
4046 DomainNotificationTypeEnum::PrivacyDelete => "PRIVACY_DELETE",
4047 DomainNotificationTypeEnum::Redeem => "REDEEM",
4048 DomainNotificationTypeEnum::Register => "REGISTER",
4049 DomainNotificationTypeEnum::Renew => "RENEW",
4050 DomainNotificationTypeEnum::RenewUndo => "RENEW_UNDO",
4051 DomainNotificationTypeEnum::Trade => "TRADE",
4052 DomainNotificationTypeEnum::TradeCancel => "TRADE_CANCEL",
4053 DomainNotificationTypeEnum::TradePurchase => "TRADE_PURCHASE",
4054 DomainNotificationTypeEnum::TradePurchaseAuthTextMessage => {
4055 "TRADE_PURCHASE_AUTH_TEXT_MESSAGE"
4056 }
4057 DomainNotificationTypeEnum::TradeResendAuthEmail => "TRADE_RESEND_AUTH_EMAIL",
4058 DomainNotificationTypeEnum::Transfer => "TRANSFER",
4059 DomainNotificationTypeEnum::TransferIn => "TRANSFER_IN",
4060 DomainNotificationTypeEnum::TransferInAccept => "TRANSFER_IN_ACCEPT",
4061 DomainNotificationTypeEnum::TransferInCancel => "TRANSFER_IN_CANCEL",
4062 DomainNotificationTypeEnum::TransferInRestart => "TRANSFER_IN_RESTART",
4063 DomainNotificationTypeEnum::TransferInRetry => "TRANSFER_IN_RETRY",
4064 DomainNotificationTypeEnum::TransferOut => "TRANSFER_OUT",
4065 DomainNotificationTypeEnum::TransferOutAccept => "TRANSFER_OUT_ACCEPT",
4066 DomainNotificationTypeEnum::TransferOutReject => "TRANSFER_OUT_REJECT",
4067 DomainNotificationTypeEnum::TransferOutRequested => "TRANSFER_OUT_REQUESTED",
4068 DomainNotificationTypeEnum::Transit => "TRANSIT",
4069 };
4070 write!(f, "{}", str_val)
4071 }
4072}
4073#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4074pub enum GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum {
4075 #[default]
4076 #[serde(rename = "AUTO_RENEWAL")]
4077 AutoRenewal,
4078 #[serde(rename = "BACKORDER")]
4079 Backorder,
4080 #[serde(rename = "BACKORDER_PURCHASE")]
4081 BackorderPurchase,
4082 #[serde(rename = "EXPIRY")]
4083 Expiry,
4084 #[serde(rename = "PREMIUM")]
4085 Premium,
4086 #[serde(rename = "PRIVACY_PURCHASE")]
4087 PrivacyPurchase,
4088 #[serde(rename = "REDEEM")]
4089 Redeem,
4090 #[serde(rename = "REGISTER")]
4091 Register,
4092 #[serde(rename = "RENEW")]
4093 Renew,
4094 #[serde(rename = "TRADE")]
4095 Trade,
4096 #[serde(rename = "TRANSFER")]
4097 Transfer,
4098}
4099impl std::fmt::Display for GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum {
4100 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4101 let str_val = match self {
4102 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::AutoRenewal => {
4103 "AUTO_RENEWAL"
4104 }
4105 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Backorder => {
4106 "BACKORDER"
4107 }
4108 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::BackorderPurchase => {
4109 "BACKORDER_PURCHASE"
4110 }
4111 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Expiry => "EXPIRY",
4112 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Premium => "PREMIUM",
4113 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::PrivacyPurchase => {
4114 "PRIVACY_PURCHASE"
4115 }
4116 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Redeem => "REDEEM",
4117 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Register => "REGISTER",
4118 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Renew => "RENEW",
4119 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Trade => "TRADE",
4120 GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::Transfer => "TRANSFER",
4121 };
4122 write!(f, "{}", str_val)
4123 }
4124}
4125#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4126pub enum GetV2CustomersCustomerIdDomainsDomainIncludesItemEnum {
4127 #[default]
4128 #[serde(rename = "actions")]
4129 Actions,
4130 #[serde(rename = "contacts")]
4131 Contacts,
4132 #[serde(rename = "dnssecRecords")]
4133 DnssecRecords,
4134 #[serde(rename = "registryStatusCodes")]
4135 RegistryStatusCodes,
4136}
4137impl std::fmt::Display for GetV2CustomersCustomerIdDomainsDomainIncludesItemEnum {
4138 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4139 let str_val = match self {
4140 GetV2CustomersCustomerIdDomainsDomainIncludesItemEnum::Actions => "actions",
4141 GetV2CustomersCustomerIdDomainsDomainIncludesItemEnum::Contacts => "contacts",
4142 GetV2CustomersCustomerIdDomainsDomainIncludesItemEnum::DnssecRecords => "dnssecRecords",
4143 GetV2CustomersCustomerIdDomainsDomainIncludesItemEnum::RegistryStatusCodes => {
4144 "registryStatusCodes"
4145 }
4146 };
4147 write!(f, "{}", str_val)
4148 }
4149}
4150#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4151pub enum ActionOriginationEnum {
4152 #[default]
4153 #[serde(rename = "USER")]
4154 User,
4155 #[serde(rename = "SYSTEM")]
4156 System,
4157}
4158impl std::fmt::Display for ActionOriginationEnum {
4159 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4160 let str_val = match self {
4161 ActionOriginationEnum::User => "USER",
4162 ActionOriginationEnum::System => "SYSTEM",
4163 };
4164 write!(f, "{}", str_val)
4165 }
4166}
4167#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4168pub enum ActionStatusEnum {
4169 #[default]
4170 #[serde(rename = "ACCEPTED")]
4171 Accepted,
4172 #[serde(rename = "AWAITING")]
4173 Awaiting,
4174 #[serde(rename = "CANCELLED")]
4175 Cancelled,
4176 #[serde(rename = "FAILED")]
4177 Failed,
4178 #[serde(rename = "PENDING")]
4179 Pending,
4180 #[serde(rename = "SUCCESS")]
4181 Success,
4182}
4183impl std::fmt::Display for ActionStatusEnum {
4184 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4185 let str_val = match self {
4186 ActionStatusEnum::Accepted => "ACCEPTED",
4187 ActionStatusEnum::Awaiting => "AWAITING",
4188 ActionStatusEnum::Cancelled => "CANCELLED",
4189 ActionStatusEnum::Failed => "FAILED",
4190 ActionStatusEnum::Pending => "PENDING",
4191 ActionStatusEnum::Success => "SUCCESS",
4192 };
4193 write!(f, "{}", str_val)
4194 }
4195}
4196#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4197pub enum ActionTypeEnum {
4198 #[default]
4199 #[serde(rename = "AUTH_CODE_PURCHASE")]
4200 AuthCodePurchase,
4201 #[serde(rename = "AUTH_CODE_REGENERATE")]
4202 AuthCodeRegenerate,
4203 #[serde(rename = "AUTO_RENEWAL")]
4204 AutoRenewal,
4205 #[serde(rename = "BACKORDER_PURCHASE")]
4206 BackorderPurchase,
4207 #[serde(rename = "BACKORDER_DELETE")]
4208 BackorderDelete,
4209 #[serde(rename = "BACKORDER_UPDATE")]
4210 BackorderUpdate,
4211 #[serde(rename = "CHANGE_OF_REGISTRANT_DELETE")]
4212 ChangeOfRegistrantDelete,
4213 #[serde(rename = "CONTACT_CREATE")]
4214 ContactCreate,
4215 #[serde(rename = "CONTACT_DELETE")]
4216 ContactDelete,
4217 #[serde(rename = "CONTACT_UPDATE")]
4218 ContactUpdate,
4219 #[serde(rename = "DNS_VERIFICATION")]
4220 DnsVerification,
4221 #[serde(rename = "DNSSEC_CREATE")]
4222 DnssecCreate,
4223 #[serde(rename = "DNSSEC_DELETE")]
4224 DnssecDelete,
4225 #[serde(rename = "DOMAIN_DELETE")]
4226 DomainDelete,
4227 #[serde(rename = "DOMAIN_UPDATE")]
4228 DomainUpdate,
4229 #[serde(rename = "DOMAIN_UPDATE_CONTACTS")]
4230 DomainUpdateContacts,
4231 #[serde(rename = "DOMAIN_UPDATE_NAME_SERVERS")]
4232 DomainUpdateNameServers,
4233 #[serde(rename = "EXPIRY")]
4234 Expiry,
4235 #[serde(rename = "HOST_CREATE")]
4236 HostCreate,
4237 #[serde(rename = "HOST_DELETE")]
4238 HostDelete,
4239 #[serde(rename = "ICANN_VERIFICATION")]
4240 IcannVerification,
4241 #[serde(rename = "MIGRATE")]
4242 Migrate,
4243 #[serde(rename = "MIGRATE_IN")]
4244 MigrateIn,
4245 #[serde(rename = "PREMIUM")]
4246 Premium,
4247 #[serde(rename = "PRIVACY_FORWARDING_UPDATE")]
4248 PrivacyForwardingUpdate,
4249 #[serde(rename = "PRIVACY_PURCHASE")]
4250 PrivacyPurchase,
4251 #[serde(rename = "PRIVACY_DELETE")]
4252 PrivacyDelete,
4253 #[serde(rename = "REDEEM")]
4254 Redeem,
4255 #[serde(rename = "REGISTER")]
4256 Register,
4257 #[serde(rename = "RENEW")]
4258 Renew,
4259 #[serde(rename = "RENEW_UNDO")]
4260 RenewUndo,
4261 #[serde(rename = "TRADE")]
4262 Trade,
4263 #[serde(rename = "TRADE_CANCEL")]
4264 TradeCancel,
4265 #[serde(rename = "TRADE_PURCHASE")]
4266 TradePurchase,
4267 #[serde(rename = "TRADE_PURCHASE_AUTH_TEXT_MESSAGE")]
4268 TradePurchaseAuthTextMessage,
4269 #[serde(rename = "TRADE_RESEND_AUTH_EMAIL")]
4270 TradeResendAuthEmail,
4271 #[serde(rename = "TRANSFER")]
4272 Transfer,
4273 #[serde(rename = "TRANSFER_IN")]
4274 TransferIn,
4275 #[serde(rename = "TRANSFER_IN_ACCEPT")]
4276 TransferInAccept,
4277 #[serde(rename = "TRANSFER_IN_CANCEL")]
4278 TransferInCancel,
4279 #[serde(rename = "TRANSFER_IN_RESTART")]
4280 TransferInRestart,
4281 #[serde(rename = "TRANSFER_IN_RETRY")]
4282 TransferInRetry,
4283 #[serde(rename = "TRANSFER_OUT")]
4284 TransferOut,
4285 #[serde(rename = "TRANSFER_OUT_ACCEPT")]
4286 TransferOutAccept,
4287 #[serde(rename = "TRANSFER_OUT_REJECT")]
4288 TransferOutReject,
4289 #[serde(rename = "TRANSFER_OUT_REQUESTED")]
4290 TransferOutRequested,
4291 #[serde(rename = "TRANSIT")]
4292 Transit,
4293}
4294impl std::fmt::Display for ActionTypeEnum {
4295 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4296 let str_val = match self {
4297 ActionTypeEnum::AuthCodePurchase => "AUTH_CODE_PURCHASE",
4298 ActionTypeEnum::AuthCodeRegenerate => "AUTH_CODE_REGENERATE",
4299 ActionTypeEnum::AutoRenewal => "AUTO_RENEWAL",
4300 ActionTypeEnum::BackorderPurchase => "BACKORDER_PURCHASE",
4301 ActionTypeEnum::BackorderDelete => "BACKORDER_DELETE",
4302 ActionTypeEnum::BackorderUpdate => "BACKORDER_UPDATE",
4303 ActionTypeEnum::ChangeOfRegistrantDelete => "CHANGE_OF_REGISTRANT_DELETE",
4304 ActionTypeEnum::ContactCreate => "CONTACT_CREATE",
4305 ActionTypeEnum::ContactDelete => "CONTACT_DELETE",
4306 ActionTypeEnum::ContactUpdate => "CONTACT_UPDATE",
4307 ActionTypeEnum::DnsVerification => "DNS_VERIFICATION",
4308 ActionTypeEnum::DnssecCreate => "DNSSEC_CREATE",
4309 ActionTypeEnum::DnssecDelete => "DNSSEC_DELETE",
4310 ActionTypeEnum::DomainDelete => "DOMAIN_DELETE",
4311 ActionTypeEnum::DomainUpdate => "DOMAIN_UPDATE",
4312 ActionTypeEnum::DomainUpdateContacts => "DOMAIN_UPDATE_CONTACTS",
4313 ActionTypeEnum::DomainUpdateNameServers => "DOMAIN_UPDATE_NAME_SERVERS",
4314 ActionTypeEnum::Expiry => "EXPIRY",
4315 ActionTypeEnum::HostCreate => "HOST_CREATE",
4316 ActionTypeEnum::HostDelete => "HOST_DELETE",
4317 ActionTypeEnum::IcannVerification => "ICANN_VERIFICATION",
4318 ActionTypeEnum::Migrate => "MIGRATE",
4319 ActionTypeEnum::MigrateIn => "MIGRATE_IN",
4320 ActionTypeEnum::Premium => "PREMIUM",
4321 ActionTypeEnum::PrivacyForwardingUpdate => "PRIVACY_FORWARDING_UPDATE",
4322 ActionTypeEnum::PrivacyPurchase => "PRIVACY_PURCHASE",
4323 ActionTypeEnum::PrivacyDelete => "PRIVACY_DELETE",
4324 ActionTypeEnum::Redeem => "REDEEM",
4325 ActionTypeEnum::Register => "REGISTER",
4326 ActionTypeEnum::Renew => "RENEW",
4327 ActionTypeEnum::RenewUndo => "RENEW_UNDO",
4328 ActionTypeEnum::Trade => "TRADE",
4329 ActionTypeEnum::TradeCancel => "TRADE_CANCEL",
4330 ActionTypeEnum::TradePurchase => "TRADE_PURCHASE",
4331 ActionTypeEnum::TradePurchaseAuthTextMessage => "TRADE_PURCHASE_AUTH_TEXT_MESSAGE",
4332 ActionTypeEnum::TradeResendAuthEmail => "TRADE_RESEND_AUTH_EMAIL",
4333 ActionTypeEnum::Transfer => "TRANSFER",
4334 ActionTypeEnum::TransferIn => "TRANSFER_IN",
4335 ActionTypeEnum::TransferInAccept => "TRANSFER_IN_ACCEPT",
4336 ActionTypeEnum::TransferInCancel => "TRANSFER_IN_CANCEL",
4337 ActionTypeEnum::TransferInRestart => "TRANSFER_IN_RESTART",
4338 ActionTypeEnum::TransferInRetry => "TRANSFER_IN_RETRY",
4339 ActionTypeEnum::TransferOut => "TRANSFER_OUT",
4340 ActionTypeEnum::TransferOutAccept => "TRANSFER_OUT_ACCEPT",
4341 ActionTypeEnum::TransferOutReject => "TRANSFER_OUT_REJECT",
4342 ActionTypeEnum::TransferOutRequested => "TRANSFER_OUT_REQUESTED",
4343 ActionTypeEnum::Transit => "TRANSIT",
4344 };
4345 write!(f, "{}", str_val)
4346 }
4347}
4348#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4349pub enum ContactDomainEncodingEnum {
4350 #[default]
4351 #[serde(rename = "ASCII")]
4352 Ascii,
4353 #[serde(rename = "UTF-8")]
4354 Utf8,
4355}
4356impl std::fmt::Display for ContactDomainEncodingEnum {
4357 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4358 let str_val = match self {
4359 ContactDomainEncodingEnum::Ascii => "ASCII",
4360 ContactDomainEncodingEnum::Utf8 => "UTF-8",
4361 };
4362 write!(f, "{}", str_val)
4363 }
4364}
4365#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4366pub enum DomainDnssecAlgorithmEnum {
4367 #[default]
4368 #[serde(rename = "RSAMD5")]
4369 Rsamd5,
4370 #[serde(rename = "DH")]
4371 Dh,
4372 #[serde(rename = "DSA")]
4373 Dsa,
4374 #[serde(rename = "RSASHA1")]
4375 Rsasha1,
4376 #[serde(rename = "DSA_NSEC3_SHA1")]
4377 DsaNsec3Sha1,
4378 #[serde(rename = "RSASHA1_NSEC3_SHA1")]
4379 Rsasha1Nsec3Sha1,
4380 #[serde(rename = "RSASHA256")]
4381 Rsasha256,
4382 #[serde(rename = "RSASHA512")]
4383 Rsasha512,
4384 #[serde(rename = "ECC_GOST")]
4385 EccGost,
4386 #[serde(rename = "ECDSAP256SHA256")]
4387 Ecdsap256sha256,
4388 #[serde(rename = "ECDSAP384SHA384")]
4389 Ecdsap384sha384,
4390 #[serde(rename = "ED25519")]
4391 Ed25519,
4392 #[serde(rename = "ED448")]
4393 Ed448,
4394 #[serde(rename = "PRIVATEDNS")]
4395 Privatedns,
4396 #[serde(rename = "PRIVATEOID")]
4397 Privateoid,
4398}
4399impl std::fmt::Display for DomainDnssecAlgorithmEnum {
4400 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4401 let str_val = match self {
4402 DomainDnssecAlgorithmEnum::Rsamd5 => "RSAMD5",
4403 DomainDnssecAlgorithmEnum::Dh => "DH",
4404 DomainDnssecAlgorithmEnum::Dsa => "DSA",
4405 DomainDnssecAlgorithmEnum::Rsasha1 => "RSASHA1",
4406 DomainDnssecAlgorithmEnum::DsaNsec3Sha1 => "DSA_NSEC3_SHA1",
4407 DomainDnssecAlgorithmEnum::Rsasha1Nsec3Sha1 => "RSASHA1_NSEC3_SHA1",
4408 DomainDnssecAlgorithmEnum::Rsasha256 => "RSASHA256",
4409 DomainDnssecAlgorithmEnum::Rsasha512 => "RSASHA512",
4410 DomainDnssecAlgorithmEnum::EccGost => "ECC_GOST",
4411 DomainDnssecAlgorithmEnum::Ecdsap256sha256 => "ECDSAP256SHA256",
4412 DomainDnssecAlgorithmEnum::Ecdsap384sha384 => "ECDSAP384SHA384",
4413 DomainDnssecAlgorithmEnum::Ed25519 => "ED25519",
4414 DomainDnssecAlgorithmEnum::Ed448 => "ED448",
4415 DomainDnssecAlgorithmEnum::Privatedns => "PRIVATEDNS",
4416 DomainDnssecAlgorithmEnum::Privateoid => "PRIVATEOID",
4417 };
4418 write!(f, "{}", str_val)
4419 }
4420}
4421#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4422pub enum DomainDnssecDigestTypeEnum {
4423 #[default]
4424 #[serde(rename = "SHA1")]
4425 Sha1,
4426 #[serde(rename = "SHA256")]
4427 Sha256,
4428 #[serde(rename = "GOST")]
4429 Gost,
4430 #[serde(rename = "SHA384")]
4431 Sha384,
4432}
4433impl std::fmt::Display for DomainDnssecDigestTypeEnum {
4434 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4435 let str_val = match self {
4436 DomainDnssecDigestTypeEnum::Sha1 => "SHA1",
4437 DomainDnssecDigestTypeEnum::Sha256 => "SHA256",
4438 DomainDnssecDigestTypeEnum::Gost => "GOST",
4439 DomainDnssecDigestTypeEnum::Sha384 => "SHA384",
4440 };
4441 write!(f, "{}", str_val)
4442 }
4443}
4444#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4445pub enum DomainDnssecFlagsEnum {
4446 #[default]
4447 #[serde(rename = "ZSK")]
4448 Zsk,
4449 #[serde(rename = "KSK")]
4450 Ksk,
4451}
4452impl std::fmt::Display for DomainDnssecFlagsEnum {
4453 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4454 let str_val = match self {
4455 DomainDnssecFlagsEnum::Zsk => "ZSK",
4456 DomainDnssecFlagsEnum::Ksk => "KSK",
4457 };
4458 write!(f, "{}", str_val)
4459 }
4460}
4461#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4462pub enum DomainDetailV2RegistryStatusCodesItemEnum {
4463 #[default]
4464 #[serde(rename = "ADD_PERIOD")]
4465 AddPeriod,
4466 #[serde(rename = "AUTO_RENEW_PERIOD")]
4467 AutoRenewPeriod,
4468 #[serde(rename = "CLIENT_DELETE_PROHIBITED")]
4469 ClientDeleteProhibited,
4470 #[serde(rename = "CLIENT_HOLD")]
4471 ClientHold,
4472 #[serde(rename = "CLIENT_RENEW_PROHIBITED")]
4473 ClientRenewProhibited,
4474 #[serde(rename = "CLIENT_TRANSFER_PROHIBITED")]
4475 ClientTransferProhibited,
4476 #[serde(rename = "CLIENT_UPDATE_PROHIBITED")]
4477 ClientUpdateProhibited,
4478 #[serde(rename = "INACTIVE")]
4479 Inactive,
4480 #[serde(rename = "OK")]
4481 Ok,
4482 #[serde(rename = "PENDING_CREATE")]
4483 PendingCreate,
4484 #[serde(rename = "PENDING_DELETE")]
4485 PendingDelete,
4486 #[serde(rename = "PENDING_RENEW")]
4487 PendingRenew,
4488 #[serde(rename = "PENDING_RESTORE")]
4489 PendingRestore,
4490 #[serde(rename = "PENDING_TRANSFER")]
4491 PendingTransfer,
4492 #[serde(rename = "PENDING_UPDATE")]
4493 PendingUpdate,
4494 #[serde(rename = "REDEMPTION_PERIOD")]
4495 RedemptionPeriod,
4496 #[serde(rename = "RENEW_PERIOD")]
4497 RenewPeriod,
4498 #[serde(rename = "SERVER_DELETE_PROHIBITED")]
4499 ServerDeleteProhibited,
4500 #[serde(rename = "SERVER_HOLD")]
4501 ServerHold,
4502 #[serde(rename = "SERVER_RENEW_PROHIBITED")]
4503 ServerRenewProhibited,
4504 #[serde(rename = "SERVER_TRANSFER_PROHIBITED")]
4505 ServerTransferProhibited,
4506 #[serde(rename = "SERVER_UPDATE_PROHIBITED")]
4507 ServerUpdateProhibited,
4508 #[serde(rename = "TRANSFER_PERIOD")]
4509 TransferPeriod,
4510}
4511impl std::fmt::Display for DomainDetailV2RegistryStatusCodesItemEnum {
4512 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4513 let str_val = match self {
4514 DomainDetailV2RegistryStatusCodesItemEnum::AddPeriod => "ADD_PERIOD",
4515 DomainDetailV2RegistryStatusCodesItemEnum::AutoRenewPeriod => "AUTO_RENEW_PERIOD",
4516 DomainDetailV2RegistryStatusCodesItemEnum::ClientDeleteProhibited => {
4517 "CLIENT_DELETE_PROHIBITED"
4518 }
4519 DomainDetailV2RegistryStatusCodesItemEnum::ClientHold => "CLIENT_HOLD",
4520 DomainDetailV2RegistryStatusCodesItemEnum::ClientRenewProhibited => {
4521 "CLIENT_RENEW_PROHIBITED"
4522 }
4523 DomainDetailV2RegistryStatusCodesItemEnum::ClientTransferProhibited => {
4524 "CLIENT_TRANSFER_PROHIBITED"
4525 }
4526 DomainDetailV2RegistryStatusCodesItemEnum::ClientUpdateProhibited => {
4527 "CLIENT_UPDATE_PROHIBITED"
4528 }
4529 DomainDetailV2RegistryStatusCodesItemEnum::Inactive => "INACTIVE",
4530 DomainDetailV2RegistryStatusCodesItemEnum::Ok => "OK",
4531 DomainDetailV2RegistryStatusCodesItemEnum::PendingCreate => "PENDING_CREATE",
4532 DomainDetailV2RegistryStatusCodesItemEnum::PendingDelete => "PENDING_DELETE",
4533 DomainDetailV2RegistryStatusCodesItemEnum::PendingRenew => "PENDING_RENEW",
4534 DomainDetailV2RegistryStatusCodesItemEnum::PendingRestore => "PENDING_RESTORE",
4535 DomainDetailV2RegistryStatusCodesItemEnum::PendingTransfer => "PENDING_TRANSFER",
4536 DomainDetailV2RegistryStatusCodesItemEnum::PendingUpdate => "PENDING_UPDATE",
4537 DomainDetailV2RegistryStatusCodesItemEnum::RedemptionPeriod => "REDEMPTION_PERIOD",
4538 DomainDetailV2RegistryStatusCodesItemEnum::RenewPeriod => "RENEW_PERIOD",
4539 DomainDetailV2RegistryStatusCodesItemEnum::ServerDeleteProhibited => {
4540 "SERVER_DELETE_PROHIBITED"
4541 }
4542 DomainDetailV2RegistryStatusCodesItemEnum::ServerHold => "SERVER_HOLD",
4543 DomainDetailV2RegistryStatusCodesItemEnum::ServerRenewProhibited => {
4544 "SERVER_RENEW_PROHIBITED"
4545 }
4546 DomainDetailV2RegistryStatusCodesItemEnum::ServerTransferProhibited => {
4547 "SERVER_TRANSFER_PROHIBITED"
4548 }
4549 DomainDetailV2RegistryStatusCodesItemEnum::ServerUpdateProhibited => {
4550 "SERVER_UPDATE_PROHIBITED"
4551 }
4552 DomainDetailV2RegistryStatusCodesItemEnum::TransferPeriod => "TRANSFER_PERIOD",
4553 };
4554 write!(f, "{}", str_val)
4555 }
4556}
4557#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4558pub enum DomainDetailV2StatusEnum {
4559 #[default]
4560 #[serde(rename = "ACTIVE")]
4561 Active,
4562 #[serde(rename = "CANCELLED")]
4563 Cancelled,
4564 #[serde(rename = "DELETED_REDEEMABLE")]
4565 DeletedRedeemable,
4566 #[serde(rename = "EXPIRED")]
4567 Expired,
4568 #[serde(rename = "FAILED")]
4569 Failed,
4570 #[serde(rename = "LOCKED_REGISTRAR")]
4571 LockedRegistrar,
4572 #[serde(rename = "PARKED")]
4573 Parked,
4574 #[serde(rename = "HELD_REGISTRAR")]
4575 HeldRegistrar,
4576 #[serde(rename = "OWNERSHIP_CHANGED")]
4577 OwnershipChanged,
4578 #[serde(rename = "PENDING_TRANSFER")]
4579 PendingTransfer,
4580 #[serde(rename = "PENDING_REGISTRATION")]
4581 PendingRegistration,
4582 #[serde(rename = "REPOSSESSED")]
4583 Repossessed,
4584 #[serde(rename = "SUSPENDED")]
4585 Suspended,
4586 #[serde(rename = "TRANSFERRED")]
4587 Transferred,
4588}
4589impl std::fmt::Display for DomainDetailV2StatusEnum {
4590 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4591 let str_val = match self {
4592 DomainDetailV2StatusEnum::Active => "ACTIVE",
4593 DomainDetailV2StatusEnum::Cancelled => "CANCELLED",
4594 DomainDetailV2StatusEnum::DeletedRedeemable => "DELETED_REDEEMABLE",
4595 DomainDetailV2StatusEnum::Expired => "EXPIRED",
4596 DomainDetailV2StatusEnum::Failed => "FAILED",
4597 DomainDetailV2StatusEnum::LockedRegistrar => "LOCKED_REGISTRAR",
4598 DomainDetailV2StatusEnum::Parked => "PARKED",
4599 DomainDetailV2StatusEnum::HeldRegistrar => "HELD_REGISTRAR",
4600 DomainDetailV2StatusEnum::OwnershipChanged => "OWNERSHIP_CHANGED",
4601 DomainDetailV2StatusEnum::PendingTransfer => "PENDING_TRANSFER",
4602 DomainDetailV2StatusEnum::PendingRegistration => "PENDING_REGISTRATION",
4603 DomainDetailV2StatusEnum::Repossessed => "REPOSSESSED",
4604 DomainDetailV2StatusEnum::Suspended => "SUSPENDED",
4605 DomainDetailV2StatusEnum::Transferred => "TRANSFERRED",
4606 };
4607 write!(f, "{}", str_val)
4608 }
4609}
4610#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4611pub enum VerificationsDomainV2DomainNameEnum {
4612 #[default]
4613 #[serde(rename = "APPROVED")]
4614 Approved,
4615 #[serde(rename = "PENDING")]
4616 Pending,
4617 #[serde(rename = "REJECTED")]
4618 Rejected,
4619 #[serde(rename = "UNABLE_TO_RETRIEVE_STATUS")]
4620 UnableToRetrieveStatus,
4621}
4622impl std::fmt::Display for VerificationsDomainV2DomainNameEnum {
4623 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4624 let str_val = match self {
4625 VerificationsDomainV2DomainNameEnum::Approved => "APPROVED",
4626 VerificationsDomainV2DomainNameEnum::Pending => "PENDING",
4627 VerificationsDomainV2DomainNameEnum::Rejected => "REJECTED",
4628 VerificationsDomainV2DomainNameEnum::UnableToRetrieveStatus => {
4629 "UNABLE_TO_RETRIEVE_STATUS"
4630 }
4631 };
4632 write!(f, "{}", str_val)
4633 }
4634}
4635#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4636pub enum VerificationsDomainV2IcannEnum {
4637 #[default]
4638 #[serde(rename = "COMPLETED")]
4639 Completed,
4640 #[serde(rename = "PENDING")]
4641 Pending,
4642 #[serde(rename = "UNABLE_TO_RETRIEVE_STATUS")]
4643 UnableToRetrieveStatus,
4644}
4645impl std::fmt::Display for VerificationsDomainV2IcannEnum {
4646 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4647 let str_val = match self {
4648 VerificationsDomainV2IcannEnum::Completed => "COMPLETED",
4649 VerificationsDomainV2IcannEnum::Pending => "PENDING",
4650 VerificationsDomainV2IcannEnum::UnableToRetrieveStatus => "UNABLE_TO_RETRIEVE_STATUS",
4651 };
4652 write!(f, "{}", str_val)
4653 }
4654}
4655#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4656pub enum VerificationsDomainV2RealNameEnum {
4657 #[default]
4658 #[serde(rename = "APPROVED")]
4659 Approved,
4660 #[serde(rename = "PENDING")]
4661 Pending,
4662 #[serde(rename = "REJECTED_DOCUMENT_OUTDATED")]
4663 RejectedDocumentOutdated,
4664 #[serde(rename = "REJECTED_EXPIRED_BUSINESS_LICENSE")]
4665 RejectedExpiredBusinessLicense,
4666 #[serde(rename = "REJECTED_EXPIRED_ORGANIZATION_CODE")]
4667 RejectedExpiredOrganizationCode,
4668 #[serde(rename = "REJECTED_ILLEGIBLE_DOCUMENT_NAME")]
4669 RejectedIllegibleDocumentName,
4670 #[serde(rename = "REJECTED_ILLEGIBLE_IDENTIFICATION")]
4671 RejectedIllegibleIdentification,
4672 #[serde(rename = "REJECTED_INCOMPLETE_IDENTIFICATION")]
4673 RejectedIncompleteIdentification,
4674 #[serde(rename = "REJECTED_INCOMPLETE_REGISTRATION_LETTER")]
4675 RejectedIncompleteRegistrationLetter,
4676 #[serde(rename = "REJECTED_INCONSISTENT_IDENTITY_CARD")]
4677 RejectedInconsistentIdentityCard,
4678 #[serde(rename = "REJECTED_INCONSISTENT_ORGANIZATION_CODE")]
4679 RejectedInconsistentOrganizationCode,
4680 #[serde(rename = "REJECTED_INCONSISTENT_REGISTRANT_NAME")]
4681 RejectedInconsistentRegistrantName,
4682 #[serde(rename = "REJECTED_INVALID_BUSINESS_LICENSE_OR_ORGANIZATION_CODE")]
4683 RejectedInvalidBusinessLicenseOrOrganizationCode,
4684 #[serde(rename = "REJECTED_INVALID_DOCUMENT")]
4685 RejectedInvalidDocument,
4686 #[serde(rename = "REJECTED_MISMATCH_BUSINESS_ID")]
4687 RejectedMismatchBusinessId,
4688 #[serde(rename = "REJECTED_MISMATCH_BUSINESS_NAME")]
4689 RejectedMismatchBusinessName,
4690 #[serde(rename = "REJECTED_MISMATCH_DOCUMENT_ID")]
4691 RejectedMismatchDocumentId,
4692 #[serde(rename = "REJECTED_MISMATCH_DOCUMENT_NAME")]
4693 RejectedMismatchDocumentName,
4694 #[serde(rename = "REJECTED_MISMATCH_DOCUMENT_TYPE")]
4695 RejectedMismatchDocumentType,
4696 #[serde(rename = "REJECTED_MISMATCH_REGISTRANT_INFO")]
4697 RejectedMismatchRegistrantInfo,
4698 #[serde(rename = "REJECTED_MISMATCH_REGISTRANT_LOCALITY")]
4699 RejectedMismatchRegistrantLocality,
4700 #[serde(rename = "REJECTED_MISMATCH_REGISTRANT_NAME")]
4701 RejectedMismatchRegistrantName,
4702 #[serde(rename = "REJECTED_UNABLE_TO_OPEN")]
4703 RejectedUnableToOpen,
4704 #[serde(rename = "REJECTED_UNABLE_TO_VERIFY")]
4705 RejectedUnableToVerify,
4706 #[serde(rename = "REJECTED_UNKNOWN_ERROR")]
4707 RejectedUnknownError,
4708 #[serde(rename = "UNABLE_TO_RETRIEVE_STATUS")]
4709 UnableToRetrieveStatus,
4710}
4711impl std::fmt::Display for VerificationsDomainV2RealNameEnum {
4712 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4713 let str_val = match self {
4714 VerificationsDomainV2RealNameEnum::Approved => "APPROVED",
4715 VerificationsDomainV2RealNameEnum::Pending => "PENDING",
4716 VerificationsDomainV2RealNameEnum::RejectedDocumentOutdated => {
4717 "REJECTED_DOCUMENT_OUTDATED"
4718 }
4719 VerificationsDomainV2RealNameEnum::RejectedExpiredBusinessLicense => {
4720 "REJECTED_EXPIRED_BUSINESS_LICENSE"
4721 }
4722 VerificationsDomainV2RealNameEnum::RejectedExpiredOrganizationCode => {
4723 "REJECTED_EXPIRED_ORGANIZATION_CODE"
4724 }
4725 VerificationsDomainV2RealNameEnum::RejectedIllegibleDocumentName => {
4726 "REJECTED_ILLEGIBLE_DOCUMENT_NAME"
4727 }
4728 VerificationsDomainV2RealNameEnum::RejectedIllegibleIdentification => {
4729 "REJECTED_ILLEGIBLE_IDENTIFICATION"
4730 }
4731 VerificationsDomainV2RealNameEnum::RejectedIncompleteIdentification => {
4732 "REJECTED_INCOMPLETE_IDENTIFICATION"
4733 }
4734 VerificationsDomainV2RealNameEnum::RejectedIncompleteRegistrationLetter => {
4735 "REJECTED_INCOMPLETE_REGISTRATION_LETTER"
4736 }
4737 VerificationsDomainV2RealNameEnum::RejectedInconsistentIdentityCard => {
4738 "REJECTED_INCONSISTENT_IDENTITY_CARD"
4739 }
4740 VerificationsDomainV2RealNameEnum::RejectedInconsistentOrganizationCode => {
4741 "REJECTED_INCONSISTENT_ORGANIZATION_CODE"
4742 }
4743 VerificationsDomainV2RealNameEnum::RejectedInconsistentRegistrantName => {
4744 "REJECTED_INCONSISTENT_REGISTRANT_NAME"
4745 }
4746 VerificationsDomainV2RealNameEnum::RejectedInvalidBusinessLicenseOrOrganizationCode => {
4747 "REJECTED_INVALID_BUSINESS_LICENSE_OR_ORGANIZATION_CODE"
4748 }
4749 VerificationsDomainV2RealNameEnum::RejectedInvalidDocument => {
4750 "REJECTED_INVALID_DOCUMENT"
4751 }
4752 VerificationsDomainV2RealNameEnum::RejectedMismatchBusinessId => {
4753 "REJECTED_MISMATCH_BUSINESS_ID"
4754 }
4755 VerificationsDomainV2RealNameEnum::RejectedMismatchBusinessName => {
4756 "REJECTED_MISMATCH_BUSINESS_NAME"
4757 }
4758 VerificationsDomainV2RealNameEnum::RejectedMismatchDocumentId => {
4759 "REJECTED_MISMATCH_DOCUMENT_ID"
4760 }
4761 VerificationsDomainV2RealNameEnum::RejectedMismatchDocumentName => {
4762 "REJECTED_MISMATCH_DOCUMENT_NAME"
4763 }
4764 VerificationsDomainV2RealNameEnum::RejectedMismatchDocumentType => {
4765 "REJECTED_MISMATCH_DOCUMENT_TYPE"
4766 }
4767 VerificationsDomainV2RealNameEnum::RejectedMismatchRegistrantInfo => {
4768 "REJECTED_MISMATCH_REGISTRANT_INFO"
4769 }
4770 VerificationsDomainV2RealNameEnum::RejectedMismatchRegistrantLocality => {
4771 "REJECTED_MISMATCH_REGISTRANT_LOCALITY"
4772 }
4773 VerificationsDomainV2RealNameEnum::RejectedMismatchRegistrantName => {
4774 "REJECTED_MISMATCH_REGISTRANT_NAME"
4775 }
4776 VerificationsDomainV2RealNameEnum::RejectedUnableToOpen => "REJECTED_UNABLE_TO_OPEN",
4777 VerificationsDomainV2RealNameEnum::RejectedUnableToVerify => {
4778 "REJECTED_UNABLE_TO_VERIFY"
4779 }
4780 VerificationsDomainV2RealNameEnum::RejectedUnknownError => "REJECTED_UNKNOWN_ERROR",
4781 VerificationsDomainV2RealNameEnum::UnableToRetrieveStatus => {
4782 "UNABLE_TO_RETRIEVE_STATUS"
4783 }
4784 };
4785 write!(f, "{}", str_val)
4786 }
4787}
4788#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
4789pub enum GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum {
4790 #[default]
4791 #[serde(rename = "AUTH_CODE_PURCHASE")]
4792 AuthCodePurchase,
4793 #[serde(rename = "AUTH_CODE_REGENERATE")]
4794 AuthCodeRegenerate,
4795 #[serde(rename = "AUTO_RENEWAL")]
4796 AutoRenewal,
4797 #[serde(rename = "BACKORDER_PURCHASE")]
4798 BackorderPurchase,
4799 #[serde(rename = "BACKORDER_DELETE")]
4800 BackorderDelete,
4801 #[serde(rename = "BACKORDER_UPDATE")]
4802 BackorderUpdate,
4803 #[serde(rename = "CHANGE_OF_REGISTRANT_DELETE")]
4804 ChangeOfRegistrantDelete,
4805 #[serde(rename = "DNS_VERIFICATION")]
4806 DnsVerification,
4807 #[serde(rename = "DNSSEC_CREATE")]
4808 DnssecCreate,
4809 #[serde(rename = "DNSSEC_DELETE")]
4810 DnssecDelete,
4811 #[serde(rename = "DOMAIN_DELETE")]
4812 DomainDelete,
4813 #[serde(rename = "DOMAIN_UPDATE")]
4814 DomainUpdate,
4815 #[serde(rename = "DOMAIN_UPDATE_CONTACTS")]
4816 DomainUpdateContacts,
4817 #[serde(rename = "DOMAIN_UPDATE_NAME_SERVERS")]
4818 DomainUpdateNameServers,
4819 #[serde(rename = "EXPIRY")]
4820 Expiry,
4821 #[serde(rename = "ICANN_VERIFICATION")]
4822 IcannVerification,
4823 #[serde(rename = "MIGRATE")]
4824 Migrate,
4825 #[serde(rename = "MIGRATE_IN")]
4826 MigrateIn,
4827 #[serde(rename = "PREMIUM")]
4828 Premium,
4829 #[serde(rename = "PRIVACY_FORWARDING_UPDATE")]
4830 PrivacyForwardingUpdate,
4831 #[serde(rename = "PRIVACY_PURCHASE")]
4832 PrivacyPurchase,
4833 #[serde(rename = "PRIVACY_DELETE")]
4834 PrivacyDelete,
4835 #[serde(rename = "REDEEM")]
4836 Redeem,
4837 #[serde(rename = "REGISTER")]
4838 Register,
4839 #[serde(rename = "RENEW")]
4840 Renew,
4841 #[serde(rename = "RENEW_UNDO")]
4842 RenewUndo,
4843 #[serde(rename = "TRADE")]
4844 Trade,
4845 #[serde(rename = "TRADE_CANCEL")]
4846 TradeCancel,
4847 #[serde(rename = "TRADE_PURCHASE")]
4848 TradePurchase,
4849 #[serde(rename = "TRADE_PURCHASE_AUTH_TEXT_MESSAGE")]
4850 TradePurchaseAuthTextMessage,
4851 #[serde(rename = "TRADE_RESEND_AUTH_EMAIL")]
4852 TradeResendAuthEmail,
4853 #[serde(rename = "TRANSFER")]
4854 Transfer,
4855 #[serde(rename = "TRANSFER_IN")]
4856 TransferIn,
4857 #[serde(rename = "TRANSFER_IN_ACCEPT")]
4858 TransferInAccept,
4859 #[serde(rename = "TRANSFER_IN_CANCEL")]
4860 TransferInCancel,
4861 #[serde(rename = "TRANSFER_IN_RESTART")]
4862 TransferInRestart,
4863 #[serde(rename = "TRANSFER_IN_RETRY")]
4864 TransferInRetry,
4865 #[serde(rename = "TRANSFER_OUT")]
4866 TransferOut,
4867 #[serde(rename = "TRANSFER_OUT_ACCEPT")]
4868 TransferOutAccept,
4869 #[serde(rename = "TRANSFER_OUT_REJECT")]
4870 TransferOutReject,
4871 #[serde(rename = "TRANSFER_OUT_REQUESTED")]
4872 TransferOutRequested,
4873 #[serde(rename = "TRANSIT")]
4874 Transit,
4875}
4876impl std::fmt::Display for GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum {
4877 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4878 let str_val = match self {
4879 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AuthCodePurchase => {
4880 "AUTH_CODE_PURCHASE"
4881 }
4882 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AuthCodeRegenerate => {
4883 "AUTH_CODE_REGENERATE"
4884 }
4885 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AutoRenewal => {
4886 "AUTO_RENEWAL"
4887 }
4888 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::BackorderPurchase => {
4889 "BACKORDER_PURCHASE"
4890 }
4891 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::BackorderDelete => {
4892 "BACKORDER_DELETE"
4893 }
4894 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::BackorderUpdate => {
4895 "BACKORDER_UPDATE"
4896 }
4897 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::ChangeOfRegistrantDelete => {
4898 "CHANGE_OF_REGISTRANT_DELETE"
4899 }
4900 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DnsVerification => {
4901 "DNS_VERIFICATION"
4902 }
4903 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DnssecCreate => {
4904 "DNSSEC_CREATE"
4905 }
4906 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DnssecDelete => {
4907 "DNSSEC_DELETE"
4908 }
4909 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainDelete => {
4910 "DOMAIN_DELETE"
4911 }
4912 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainUpdate => {
4913 "DOMAIN_UPDATE"
4914 }
4915 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainUpdateContacts => {
4916 "DOMAIN_UPDATE_CONTACTS"
4917 }
4918 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::DomainUpdateNameServers => {
4919 "DOMAIN_UPDATE_NAME_SERVERS"
4920 }
4921 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Expiry => "EXPIRY",
4922 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::IcannVerification => {
4923 "ICANN_VERIFICATION"
4924 }
4925 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Migrate => {
4926 "MIGRATE"
4927 }
4928 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::MigrateIn => {
4929 "MIGRATE_IN"
4930 }
4931 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Premium => {
4932 "PREMIUM"
4933 }
4934 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::PrivacyForwardingUpdate => {
4935 "PRIVACY_FORWARDING_UPDATE"
4936 }
4937 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::PrivacyPurchase => {
4938 "PRIVACY_PURCHASE"
4939 }
4940 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::PrivacyDelete => {
4941 "PRIVACY_DELETE"
4942 }
4943 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Redeem => "REDEEM",
4944 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Register => {
4945 "REGISTER"
4946 }
4947 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Renew => "RENEW",
4948 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::RenewUndo => {
4949 "RENEW_UNDO"
4950 }
4951 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Trade => "TRADE",
4952 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradeCancel => {
4953 "TRADE_CANCEL"
4954 }
4955 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradePurchase => {
4956 "TRADE_PURCHASE"
4957 }
4958 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradePurchaseAuthTextMessage => {
4959 "TRADE_PURCHASE_AUTH_TEXT_MESSAGE"
4960 }
4961 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TradeResendAuthEmail => {
4962 "TRADE_RESEND_AUTH_EMAIL"
4963 }
4964 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Transfer => {
4965 "TRANSFER"
4966 }
4967 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferIn => {
4968 "TRANSFER_IN"
4969 }
4970 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInAccept => {
4971 "TRANSFER_IN_ACCEPT"
4972 }
4973 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInCancel => {
4974 "TRANSFER_IN_CANCEL"
4975 }
4976 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInRestart => {
4977 "TRANSFER_IN_RESTART"
4978 }
4979 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferInRetry => {
4980 "TRANSFER_IN_RETRY"
4981 }
4982 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOut => {
4983 "TRANSFER_OUT"
4984 }
4985 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOutAccept => {
4986 "TRANSFER_OUT_ACCEPT"
4987 }
4988 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOutReject => {
4989 "TRANSFER_OUT_REJECT"
4990 }
4991 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::TransferOutRequested => {
4992 "TRANSFER_OUT_REQUESTED"
4993 }
4994 GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::Transit => {
4995 "TRANSIT"
4996 }
4997 };
4998 write!(f, "{}", str_val)
4999 }
5000}
5001#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5002pub enum DomainPrivacyForwardingEmailPreferenceEnum {
5003 #[default]
5004 #[serde(rename = "EMAIL_FILTER")]
5005 EmailFilter,
5006 #[serde(rename = "EMAIL_SEND_ALL")]
5007 EmailSendAll,
5008 #[serde(rename = "EMAIL_SEND_NONE")]
5009 EmailSendNone,
5010}
5011impl std::fmt::Display for DomainPrivacyForwardingEmailPreferenceEnum {
5012 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5013 let str_val = match self {
5014 DomainPrivacyForwardingEmailPreferenceEnum::EmailFilter => "EMAIL_FILTER",
5015 DomainPrivacyForwardingEmailPreferenceEnum::EmailSendAll => "EMAIL_SEND_ALL",
5016 DomainPrivacyForwardingEmailPreferenceEnum::EmailSendNone => "EMAIL_SEND_NONE",
5017 };
5018 write!(f, "{}", str_val)
5019 }
5020}
5021#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5022pub enum GetV2DomainsMaintenancesStatusEnum {
5023 #[default]
5024 #[serde(rename = "ACTIVE")]
5025 Active,
5026 #[serde(rename = "CANCELLED")]
5027 Cancelled,
5028}
5029impl std::fmt::Display for GetV2DomainsMaintenancesStatusEnum {
5030 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5031 let str_val = match self {
5032 GetV2DomainsMaintenancesStatusEnum::Active => "ACTIVE",
5033 GetV2DomainsMaintenancesStatusEnum::Cancelled => "CANCELLED",
5034 };
5035 write!(f, "{}", str_val)
5036 }
5037}
5038#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5039pub enum MaintenanceEnvironmentEnum {
5040 #[default]
5041 #[serde(rename = "OTE")]
5042 Ote,
5043 #[serde(rename = "PRODUCTION")]
5044 Production,
5045}
5046impl std::fmt::Display for MaintenanceEnvironmentEnum {
5047 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5048 let str_val = match self {
5049 MaintenanceEnvironmentEnum::Ote => "OTE",
5050 MaintenanceEnvironmentEnum::Production => "PRODUCTION",
5051 };
5052 write!(f, "{}", str_val)
5053 }
5054}
5055#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5056pub enum MaintenanceReasonEnum {
5057 #[default]
5058 #[serde(rename = "EMERGENCY")]
5059 Emergency,
5060 #[serde(rename = "PLANNED")]
5061 Planned,
5062}
5063impl std::fmt::Display for MaintenanceReasonEnum {
5064 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5065 let str_val = match self {
5066 MaintenanceReasonEnum::Emergency => "EMERGENCY",
5067 MaintenanceReasonEnum::Planned => "PLANNED",
5068 };
5069 write!(f, "{}", str_val)
5070 }
5071}
5072#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5073pub enum MaintenanceStatusEnum {
5074 #[default]
5075 #[serde(rename = "ACTIVE")]
5076 Active,
5077 #[serde(rename = "CANCELLED")]
5078 Cancelled,
5079}
5080impl std::fmt::Display for MaintenanceStatusEnum {
5081 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5082 let str_val = match self {
5083 MaintenanceStatusEnum::Active => "ACTIVE",
5084 MaintenanceStatusEnum::Cancelled => "CANCELLED",
5085 };
5086 write!(f, "{}", str_val)
5087 }
5088}
5089#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5090pub enum MaintenanceTypeEnum {
5091 #[default]
5092 #[serde(rename = "API")]
5093 Api,
5094 #[serde(rename = "REGISTRY")]
5095 Registry,
5096 #[serde(rename = "UI")]
5097 Ui,
5098}
5099impl std::fmt::Display for MaintenanceTypeEnum {
5100 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5101 let str_val = match self {
5102 MaintenanceTypeEnum::Api => "API",
5103 MaintenanceTypeEnum::Registry => "REGISTRY",
5104 MaintenanceTypeEnum::Ui => "UI",
5105 };
5106 write!(f, "{}", str_val)
5107 }
5108}
5109#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5110pub enum MaintenanceDetailEnvironmentEnum {
5111 #[default]
5112 #[serde(rename = "OTE")]
5113 Ote,
5114 #[serde(rename = "PRODUCTION")]
5115 Production,
5116}
5117impl std::fmt::Display for MaintenanceDetailEnvironmentEnum {
5118 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5119 let str_val = match self {
5120 MaintenanceDetailEnvironmentEnum::Ote => "OTE",
5121 MaintenanceDetailEnvironmentEnum::Production => "PRODUCTION",
5122 };
5123 write!(f, "{}", str_val)
5124 }
5125}
5126#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5127pub enum MaintenanceDetailReasonEnum {
5128 #[default]
5129 #[serde(rename = "EMERGENCY")]
5130 Emergency,
5131 #[serde(rename = "PLANNED")]
5132 Planned,
5133}
5134impl std::fmt::Display for MaintenanceDetailReasonEnum {
5135 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5136 let str_val = match self {
5137 MaintenanceDetailReasonEnum::Emergency => "EMERGENCY",
5138 MaintenanceDetailReasonEnum::Planned => "PLANNED",
5139 };
5140 write!(f, "{}", str_val)
5141 }
5142}
5143#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5144pub enum MaintenanceDetailStatusEnum {
5145 #[default]
5146 #[serde(rename = "ACTIVE")]
5147 Active,
5148 #[serde(rename = "CANCELLED")]
5149 Cancelled,
5150}
5151impl std::fmt::Display for MaintenanceDetailStatusEnum {
5152 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5153 let str_val = match self {
5154 MaintenanceDetailStatusEnum::Active => "ACTIVE",
5155 MaintenanceDetailStatusEnum::Cancelled => "CANCELLED",
5156 };
5157 write!(f, "{}", str_val)
5158 }
5159}
5160#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5161pub enum MaintenanceSystemImpactItemEnum {
5162 #[default]
5163 #[serde(rename = "DELAYED")]
5164 Delayed,
5165 #[serde(rename = "DOWN")]
5166 Down,
5167 #[serde(rename = "NON_AUTHORITATIVE")]
5168 NonAuthoritative,
5169 #[serde(rename = "PARTIAL")]
5170 Partial,
5171}
5172impl std::fmt::Display for MaintenanceSystemImpactItemEnum {
5173 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5174 let str_val = match self {
5175 MaintenanceSystemImpactItemEnum::Delayed => "DELAYED",
5176 MaintenanceSystemImpactItemEnum::Down => "DOWN",
5177 MaintenanceSystemImpactItemEnum::NonAuthoritative => "NON_AUTHORITATIVE",
5178 MaintenanceSystemImpactItemEnum::Partial => "PARTIAL",
5179 };
5180 write!(f, "{}", str_val)
5181 }
5182}
5183#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5184pub enum MaintenanceSystemNameEnum {
5185 #[default]
5186 #[serde(rename = "DOMAIN_CHECKS")]
5187 DomainChecks,
5188 #[serde(rename = "DOMAIN_MANAGEMENT")]
5189 DomainManagement,
5190 #[serde(rename = "DOMAIN_REGISTRATION")]
5191 DomainRegistration,
5192 #[serde(rename = "DOMAIN_REGISTRATION_DATA")]
5193 DomainRegistrationData,
5194 #[serde(rename = "DOMAIN_RESOLUTION")]
5195 DomainResolution,
5196 #[serde(rename = "RESELLER_ADMIN_PORTAL")]
5197 ResellerAdminPortal,
5198 #[serde(rename = "RESELLER_STOREFRONT")]
5199 ResellerStorefront,
5200}
5201impl std::fmt::Display for MaintenanceSystemNameEnum {
5202 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5203 let str_val = match self {
5204 MaintenanceSystemNameEnum::DomainChecks => "DOMAIN_CHECKS",
5205 MaintenanceSystemNameEnum::DomainManagement => "DOMAIN_MANAGEMENT",
5206 MaintenanceSystemNameEnum::DomainRegistration => "DOMAIN_REGISTRATION",
5207 MaintenanceSystemNameEnum::DomainRegistrationData => "DOMAIN_REGISTRATION_DATA",
5208 MaintenanceSystemNameEnum::DomainResolution => "DOMAIN_RESOLUTION",
5209 MaintenanceSystemNameEnum::ResellerAdminPortal => "RESELLER_ADMIN_PORTAL",
5210 MaintenanceSystemNameEnum::ResellerStorefront => "RESELLER_STOREFRONT",
5211 };
5212 write!(f, "{}", str_val)
5213 }
5214}
5215#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5216pub enum MaintenanceDetailTypeEnum {
5217 #[default]
5218 #[serde(rename = "API")]
5219 Api,
5220 #[serde(rename = "REGISTRY")]
5221 Registry,
5222 #[serde(rename = "UI")]
5223 Ui,
5224}
5225impl std::fmt::Display for MaintenanceDetailTypeEnum {
5226 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5227 let str_val = match self {
5228 MaintenanceDetailTypeEnum::Api => "API",
5229 MaintenanceDetailTypeEnum::Registry => "REGISTRY",
5230 MaintenanceDetailTypeEnum::Ui => "UI",
5231 };
5232 write!(f, "{}", str_val)
5233 }
5234}
5235#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5236pub enum ConsentDomainUpdateAgreementKeysItemEnum {
5237 #[default]
5238 #[serde(rename = "EXPOSE_WHOIS")]
5239 ExposeWhois,
5240}
5241impl std::fmt::Display for ConsentDomainUpdateAgreementKeysItemEnum {
5242 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5243 let str_val = match self {
5244 ConsentDomainUpdateAgreementKeysItemEnum::ExposeWhois => "EXPOSE_WHOIS",
5245 };
5246 write!(f, "{}", str_val)
5247 }
5248}
5249#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5250pub enum DomainPrivacyForwardingUpdateEmailPreferenceEnum {
5251 #[default]
5252 #[serde(rename = "EMAIL_FILTER")]
5253 EmailFilter,
5254 #[serde(rename = "EMAIL_SEND_ALL")]
5255 EmailSendAll,
5256 #[serde(rename = "EMAIL_SEND_NONE")]
5257 EmailSendNone,
5258}
5259impl std::fmt::Display for DomainPrivacyForwardingUpdateEmailPreferenceEnum {
5260 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5261 let str_val = match self {
5262 DomainPrivacyForwardingUpdateEmailPreferenceEnum::EmailFilter => "EMAIL_FILTER",
5263 DomainPrivacyForwardingUpdateEmailPreferenceEnum::EmailSendAll => "EMAIL_SEND_ALL",
5264 DomainPrivacyForwardingUpdateEmailPreferenceEnum::EmailSendNone => "EMAIL_SEND_NONE",
5265 };
5266 write!(f, "{}", str_val)
5267 }
5268}
5269#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5270pub enum DomainPrivacyForwardingUpdatePrivateEmailTypeEnum {
5271 #[default]
5272 #[serde(rename = "DEFAULT")]
5273 Default,
5274 #[serde(rename = "RANDOM")]
5275 Random,
5276}
5277impl std::fmt::Display for DomainPrivacyForwardingUpdatePrivateEmailTypeEnum {
5278 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5279 let str_val = match self {
5280 DomainPrivacyForwardingUpdatePrivateEmailTypeEnum::Default => "DEFAULT",
5281 DomainPrivacyForwardingUpdatePrivateEmailTypeEnum::Random => "RANDOM",
5282 };
5283 write!(f, "{}", str_val)
5284 }
5285}
5286#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5287pub enum PostV1DomainsAvailableCheckTypeEnum {
5288 #[default]
5289 #[serde(rename = "FAST")]
5290 Fast,
5291 #[serde(rename = "FULL")]
5292 Full,
5293}
5294impl std::fmt::Display for PostV1DomainsAvailableCheckTypeEnum {
5295 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5296 let str_val = match self {
5297 PostV1DomainsAvailableCheckTypeEnum::Fast => "FAST",
5298 PostV1DomainsAvailableCheckTypeEnum::Full => "FULL",
5299 };
5300 write!(f, "{}", str_val)
5301 }
5302}
5303#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5304pub enum DomainsContactsBulkEntityTypeEnum {
5305 #[default]
5306 #[serde(rename = "ABORIGINAL")]
5307 Aboriginal,
5308 #[serde(rename = "ASSOCIATION")]
5309 Association,
5310 #[serde(rename = "CITIZEN")]
5311 Citizen,
5312 #[serde(rename = "CORPORATION")]
5313 Corporation,
5314 #[serde(rename = "EDUCATIONAL")]
5315 Educational,
5316 #[serde(rename = "GOVERNMENT")]
5317 Government,
5318 #[serde(rename = "HOSPITAL")]
5319 Hospital,
5320 #[serde(rename = "INDIAN_BAND")]
5321 IndianBand,
5322 #[serde(rename = "LEGAL_REPRESENTATIVE")]
5323 LegalRepresentative,
5324 #[serde(rename = "LIBRARY_ARCHIVE_MUSEUM")]
5325 LibraryArchiveMuseum,
5326 #[serde(rename = "MARK_REGISTERED")]
5327 MarkRegistered,
5328 #[serde(rename = "MARK_TRADE")]
5329 MarkTrade,
5330 #[serde(rename = "PARTNERSHIP")]
5331 Partnership,
5332 #[serde(rename = "POLITICAL_PARTY")]
5333 PoliticalParty,
5334 #[serde(rename = "RESIDENT_PERMANENT")]
5335 ResidentPermanent,
5336 #[serde(rename = "TRUST")]
5337 Trust,
5338 #[serde(rename = "UNION")]
5339 Union,
5340}
5341impl std::fmt::Display for DomainsContactsBulkEntityTypeEnum {
5342 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5343 let str_val = match self {
5344 DomainsContactsBulkEntityTypeEnum::Aboriginal => "ABORIGINAL",
5345 DomainsContactsBulkEntityTypeEnum::Association => "ASSOCIATION",
5346 DomainsContactsBulkEntityTypeEnum::Citizen => "CITIZEN",
5347 DomainsContactsBulkEntityTypeEnum::Corporation => "CORPORATION",
5348 DomainsContactsBulkEntityTypeEnum::Educational => "EDUCATIONAL",
5349 DomainsContactsBulkEntityTypeEnum::Government => "GOVERNMENT",
5350 DomainsContactsBulkEntityTypeEnum::Hospital => "HOSPITAL",
5351 DomainsContactsBulkEntityTypeEnum::IndianBand => "INDIAN_BAND",
5352 DomainsContactsBulkEntityTypeEnum::LegalRepresentative => "LEGAL_REPRESENTATIVE",
5353 DomainsContactsBulkEntityTypeEnum::LibraryArchiveMuseum => "LIBRARY_ARCHIVE_MUSEUM",
5354 DomainsContactsBulkEntityTypeEnum::MarkRegistered => "MARK_REGISTERED",
5355 DomainsContactsBulkEntityTypeEnum::MarkTrade => "MARK_TRADE",
5356 DomainsContactsBulkEntityTypeEnum::Partnership => "PARTNERSHIP",
5357 DomainsContactsBulkEntityTypeEnum::PoliticalParty => "POLITICAL_PARTY",
5358 DomainsContactsBulkEntityTypeEnum::ResidentPermanent => "RESIDENT_PERMANENT",
5359 DomainsContactsBulkEntityTypeEnum::Trust => "TRUST",
5360 DomainsContactsBulkEntityTypeEnum::Union => "UNION",
5361 };
5362 write!(f, "{}", str_val)
5363 }
5364}
5365#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5366pub enum DomainForwardingCreateTypeEnum {
5367 #[default]
5368 #[serde(rename = "MASKED")]
5369 Masked,
5370 #[serde(rename = "REDIRECT_PERMANENT")]
5371 RedirectPermanent,
5372 #[serde(rename = "REDIRECT_TEMPORARY")]
5373 RedirectTemporary,
5374}
5375impl std::fmt::Display for DomainForwardingCreateTypeEnum {
5376 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5377 let str_val = match self {
5378 DomainForwardingCreateTypeEnum::Masked => "MASKED",
5379 DomainForwardingCreateTypeEnum::RedirectPermanent => "REDIRECT_PERMANENT",
5380 DomainForwardingCreateTypeEnum::RedirectTemporary => "REDIRECT_TEMPORARY",
5381 };
5382 write!(f, "{}", str_val)
5383 }
5384}
5385#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5386pub enum ContactDomainCreateEncodingEnum {
5387 #[default]
5388 #[serde(rename = "ASCII")]
5389 Ascii,
5390 #[serde(rename = "UTF-8")]
5391 Utf8,
5392}
5393impl std::fmt::Display for ContactDomainCreateEncodingEnum {
5394 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5395 let str_val = match self {
5396 ContactDomainCreateEncodingEnum::Ascii => "ASCII",
5397 ContactDomainCreateEncodingEnum::Utf8 => "UTF-8",
5398 };
5399 write!(f, "{}", str_val)
5400 }
5401}
5402#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5403pub enum PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum {
5404 #[default]
5405 #[serde(rename = "EVIDENCE_OF_FRAUD")]
5406 EvidenceOfFraud,
5407 #[serde(rename = "URDP_ACTION")]
5408 UrdpAction,
5409 #[serde(rename = "COURT_ORDER")]
5410 CourtOrder,
5411 #[serde(rename = "DISPUTE_OVER_IDENTITY")]
5412 DisputeOverIdentity,
5413 #[serde(rename = "NO_PAYMENT_FOR_PREVIOUS_REGISTRATION_PERIOD")]
5414 NoPaymentForPreviousRegistrationPeriod,
5415 #[serde(rename = "WRITTEN_OBJECTION")]
5416 WrittenObjection,
5417 #[serde(rename = "TRANSFERRED_WITHIN_SIXTY_DAYS")]
5418 TransferredWithinSixtyDays,
5419}
5420impl std::fmt::Display for PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum {
5421 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5422 let str_val = match self {
5423 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::EvidenceOfFraud => {
5424 "EVIDENCE_OF_FRAUD"
5425 }
5426 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::UrdpAction => {
5427 "URDP_ACTION"
5428 }
5429 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::CourtOrder => {
5430 "COURT_ORDER"
5431 }
5432 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::DisputeOverIdentity => {
5433 "DISPUTE_OVER_IDENTITY"
5434 }
5435 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::NoPaymentForPreviousRegistrationPeriod => {
5436 "NO_PAYMENT_FOR_PREVIOUS_REGISTRATION_PERIOD"
5437 }
5438 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::WrittenObjection => {
5439 "WRITTEN_OBJECTION"
5440 }
5441 PostV2CustomersCustomerIdDomainsDomainTransferOutRejectReasonEnum::TransferredWithinSixtyDays => {
5442 "TRANSFERRED_WITHIN_SIXTY_DAYS"
5443 }
5444 };
5445 write!(f, "{}", str_val)
5446 }
5447}
5448#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5449pub enum PutV1DomainsDomainRecordsTypeTypeEnum {
5450 #[default]
5451 #[serde(rename = "A")]
5452 A,
5453 #[serde(rename = "AAAA")]
5454 Aaaa,
5455 #[serde(rename = "CNAME")]
5456 Cname,
5457 #[serde(rename = "MX")]
5458 Mx,
5459 #[serde(rename = "NS")]
5460 Ns,
5461 #[serde(rename = "SOA")]
5462 Soa,
5463 #[serde(rename = "SRV")]
5464 Srv,
5465 #[serde(rename = "TXT")]
5466 Txt,
5467}
5468impl std::fmt::Display for PutV1DomainsDomainRecordsTypeTypeEnum {
5469 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5470 let str_val = match self {
5471 PutV1DomainsDomainRecordsTypeTypeEnum::A => "A",
5472 PutV1DomainsDomainRecordsTypeTypeEnum::Aaaa => "AAAA",
5473 PutV1DomainsDomainRecordsTypeTypeEnum::Cname => "CNAME",
5474 PutV1DomainsDomainRecordsTypeTypeEnum::Mx => "MX",
5475 PutV1DomainsDomainRecordsTypeTypeEnum::Ns => "NS",
5476 PutV1DomainsDomainRecordsTypeTypeEnum::Soa => "SOA",
5477 PutV1DomainsDomainRecordsTypeTypeEnum::Srv => "SRV",
5478 PutV1DomainsDomainRecordsTypeTypeEnum::Txt => "TXT",
5479 };
5480 write!(f, "{}", str_val)
5481 }
5482}
5483#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5484pub enum PutV1DomainsDomainRecordsTypeNameTypeEnum {
5485 #[default]
5486 #[serde(rename = "A")]
5487 A,
5488 #[serde(rename = "AAAA")]
5489 Aaaa,
5490 #[serde(rename = "CNAME")]
5491 Cname,
5492 #[serde(rename = "MX")]
5493 Mx,
5494 #[serde(rename = "NS")]
5495 Ns,
5496 #[serde(rename = "SOA")]
5497 Soa,
5498 #[serde(rename = "SRV")]
5499 Srv,
5500 #[serde(rename = "TXT")]
5501 Txt,
5502}
5503impl std::fmt::Display for PutV1DomainsDomainRecordsTypeNameTypeEnum {
5504 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5505 let str_val = match self {
5506 PutV1DomainsDomainRecordsTypeNameTypeEnum::A => "A",
5507 PutV1DomainsDomainRecordsTypeNameTypeEnum::Aaaa => "AAAA",
5508 PutV1DomainsDomainRecordsTypeNameTypeEnum::Cname => "CNAME",
5509 PutV1DomainsDomainRecordsTypeNameTypeEnum::Mx => "MX",
5510 PutV1DomainsDomainRecordsTypeNameTypeEnum::Ns => "NS",
5511 PutV1DomainsDomainRecordsTypeNameTypeEnum::Soa => "SOA",
5512 PutV1DomainsDomainRecordsTypeNameTypeEnum::Srv => "SRV",
5513 PutV1DomainsDomainRecordsTypeNameTypeEnum::Txt => "TXT",
5514 };
5515 write!(f, "{}", str_val)
5516 }
5517}
5518#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
5519pub enum PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum {
5520 #[default]
5521 #[serde(rename = "AUTH_CODE_PURCHASE")]
5522 AuthCodePurchase,
5523 #[serde(rename = "AUTH_CODE_REGENERATE")]
5524 AuthCodeRegenerate,
5525 #[serde(rename = "AUTO_RENEWAL")]
5526 AutoRenewal,
5527 #[serde(rename = "BACKORDER")]
5528 Backorder,
5529 #[serde(rename = "BACKORDER_PURCHASE")]
5530 BackorderPurchase,
5531 #[serde(rename = "BACKORDER_DELETE")]
5532 BackorderDelete,
5533 #[serde(rename = "BACKORDER_UPDATE")]
5534 BackorderUpdate,
5535 #[serde(rename = "CHANGE_OF_REGISTRANT_DELETE")]
5536 ChangeOfRegistrantDelete,
5537 #[serde(rename = "CONTACT_CREATE")]
5538 ContactCreate,
5539 #[serde(rename = "CONTACT_DELETE")]
5540 ContactDelete,
5541 #[serde(rename = "CONTACT_UPDATE")]
5542 ContactUpdate,
5543 #[serde(rename = "DNS_VERIFICATION")]
5544 DnsVerification,
5545 #[serde(rename = "DNSSEC_CREATE")]
5546 DnssecCreate,
5547 #[serde(rename = "DNSSEC_DELETE")]
5548 DnssecDelete,
5549 #[serde(rename = "DOMAIN_DELETE")]
5550 DomainDelete,
5551 #[serde(rename = "DOMAIN_UPDATE")]
5552 DomainUpdate,
5553 #[serde(rename = "DOMAIN_UPDATE_CONTACTS")]
5554 DomainUpdateContacts,
5555 #[serde(rename = "DOMAIN_UPDATE_NAME_SERVERS")]
5556 DomainUpdateNameServers,
5557 #[serde(rename = "EXPIRY")]
5558 Expiry,
5559 #[serde(rename = "HOST_CREATE")]
5560 HostCreate,
5561 #[serde(rename = "HOST_DELETE")]
5562 HostDelete,
5563 #[serde(rename = "ICANN_VERIFICATION")]
5564 IcannVerification,
5565 #[serde(rename = "MIGRATE")]
5566 Migrate,
5567 #[serde(rename = "MIGRATE_IN")]
5568 MigrateIn,
5569 #[serde(rename = "PREMIUM")]
5570 Premium,
5571 #[serde(rename = "PRIVACY_FORWARDING_UPDATE")]
5572 PrivacyForwardingUpdate,
5573 #[serde(rename = "PRIVACY_PURCHASE")]
5574 PrivacyPurchase,
5575 #[serde(rename = "PRIVACY_DELETE")]
5576 PrivacyDelete,
5577 #[serde(rename = "REDEEM")]
5578 Redeem,
5579 #[serde(rename = "REGISTER")]
5580 Register,
5581 #[serde(rename = "RENEW")]
5582 Renew,
5583 #[serde(rename = "RENEW_UNDO")]
5584 RenewUndo,
5585 #[serde(rename = "TRADE")]
5586 Trade,
5587 #[serde(rename = "TRADE_CANCEL")]
5588 TradeCancel,
5589 #[serde(rename = "TRADE_PURCHASE")]
5590 TradePurchase,
5591 #[serde(rename = "TRADE_PURCHASE_AUTH_TEXT_MESSAGE")]
5592 TradePurchaseAuthTextMessage,
5593 #[serde(rename = "TRADE_RESEND_AUTH_EMAIL")]
5594 TradeResendAuthEmail,
5595 #[serde(rename = "TRANSFER")]
5596 Transfer,
5597 #[serde(rename = "TRANSFER_IN")]
5598 TransferIn,
5599 #[serde(rename = "TRANSFER_IN_ACCEPT")]
5600 TransferInAccept,
5601 #[serde(rename = "TRANSFER_IN_CANCEL")]
5602 TransferInCancel,
5603 #[serde(rename = "TRANSFER_IN_RESTART")]
5604 TransferInRestart,
5605 #[serde(rename = "TRANSFER_IN_RETRY")]
5606 TransferInRetry,
5607 #[serde(rename = "TRANSFER_OUT")]
5608 TransferOut,
5609 #[serde(rename = "TRANSFER_OUT_ACCEPT")]
5610 TransferOutAccept,
5611 #[serde(rename = "TRANSFER_OUT_REJECT")]
5612 TransferOutReject,
5613 #[serde(rename = "TRANSFER_OUT_REQUESTED")]
5614 TransferOutRequested,
5615 #[serde(rename = "TRANSIT")]
5616 Transit,
5617}
5618impl std::fmt::Display for PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum {
5619 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5620 let str_val = match self {
5621 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::AuthCodePurchase => {
5622 "AUTH_CODE_PURCHASE"
5623 }
5624 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::AuthCodeRegenerate => {
5625 "AUTH_CODE_REGENERATE"
5626 }
5627 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::AutoRenewal => {
5628 "AUTO_RENEWAL"
5629 }
5630 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Backorder => {
5631 "BACKORDER"
5632 }
5633 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::BackorderPurchase => {
5634 "BACKORDER_PURCHASE"
5635 }
5636 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::BackorderDelete => {
5637 "BACKORDER_DELETE"
5638 }
5639 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::BackorderUpdate => {
5640 "BACKORDER_UPDATE"
5641 }
5642 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::ChangeOfRegistrantDelete => {
5643 "CHANGE_OF_REGISTRANT_DELETE"
5644 }
5645 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::ContactCreate => {
5646 "CONTACT_CREATE"
5647 }
5648 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::ContactDelete => {
5649 "CONTACT_DELETE"
5650 }
5651 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::ContactUpdate => {
5652 "CONTACT_UPDATE"
5653 }
5654 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DnsVerification => {
5655 "DNS_VERIFICATION"
5656 }
5657 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DnssecCreate => {
5658 "DNSSEC_CREATE"
5659 }
5660 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DnssecDelete => {
5661 "DNSSEC_DELETE"
5662 }
5663 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DomainDelete => {
5664 "DOMAIN_DELETE"
5665 }
5666 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DomainUpdate => {
5667 "DOMAIN_UPDATE"
5668 }
5669 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DomainUpdateContacts => {
5670 "DOMAIN_UPDATE_CONTACTS"
5671 }
5672 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::DomainUpdateNameServers => {
5673 "DOMAIN_UPDATE_NAME_SERVERS"
5674 }
5675 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Expiry => {
5676 "EXPIRY"
5677 }
5678 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::HostCreate => {
5679 "HOST_CREATE"
5680 }
5681 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::HostDelete => {
5682 "HOST_DELETE"
5683 }
5684 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::IcannVerification => {
5685 "ICANN_VERIFICATION"
5686 }
5687 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Migrate => {
5688 "MIGRATE"
5689 }
5690 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::MigrateIn => {
5691 "MIGRATE_IN"
5692 }
5693 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Premium => {
5694 "PREMIUM"
5695 }
5696 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::PrivacyForwardingUpdate => {
5697 "PRIVACY_FORWARDING_UPDATE"
5698 }
5699 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::PrivacyPurchase => {
5700 "PRIVACY_PURCHASE"
5701 }
5702 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::PrivacyDelete => {
5703 "PRIVACY_DELETE"
5704 }
5705 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Redeem => {
5706 "REDEEM"
5707 }
5708 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Register => {
5709 "REGISTER"
5710 }
5711 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Renew => {
5712 "RENEW"
5713 }
5714 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::RenewUndo => {
5715 "RENEW_UNDO"
5716 }
5717 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Trade => {
5718 "TRADE"
5719 }
5720 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TradeCancel => {
5721 "TRADE_CANCEL"
5722 }
5723 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TradePurchase => {
5724 "TRADE_PURCHASE"
5725 }
5726 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TradePurchaseAuthTextMessage => {
5727 "TRADE_PURCHASE_AUTH_TEXT_MESSAGE"
5728 }
5729 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TradeResendAuthEmail => {
5730 "TRADE_RESEND_AUTH_EMAIL"
5731 }
5732 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Transfer => {
5733 "TRANSFER"
5734 }
5735 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferIn => {
5736 "TRANSFER_IN"
5737 }
5738 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferInAccept => {
5739 "TRANSFER_IN_ACCEPT"
5740 }
5741 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferInCancel => {
5742 "TRANSFER_IN_CANCEL"
5743 }
5744 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferInRestart => {
5745 "TRANSFER_IN_RESTART"
5746 }
5747 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferInRetry => {
5748 "TRANSFER_IN_RETRY"
5749 }
5750 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferOut => {
5751 "TRANSFER_OUT"
5752 }
5753 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferOutAccept => {
5754 "TRANSFER_OUT_ACCEPT"
5755 }
5756 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferOutReject => {
5757 "TRANSFER_OUT_REJECT"
5758 }
5759 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::TransferOutRequested => {
5760 "TRANSFER_OUT_REQUESTED"
5761 }
5762 PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::Transit => {
5763 "TRANSIT"
5764 }
5765 };
5766 write!(f, "{}", str_val)
5767 }
5768}