pulumiverse-scaleway 1.26.0a1742897201__py3-none-any.whl → 1.26.0a1743166124__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumiverse_scaleway/__init__.py +105 -0
- pulumiverse_scaleway/_inputs.py +663 -0
- pulumiverse_scaleway/apple_silicon_server.py +105 -0
- pulumiverse_scaleway/applesilicon/server.py +105 -0
- pulumiverse_scaleway/domain/__init__.py +1 -0
- pulumiverse_scaleway/domain/_inputs.py +2697 -0
- pulumiverse_scaleway/domain/outputs.py +2145 -0
- pulumiverse_scaleway/domain/registration.py +777 -0
- pulumiverse_scaleway/edge_services_backend_stage.py +472 -0
- pulumiverse_scaleway/edge_services_cache_stage.py +490 -0
- pulumiverse_scaleway/edge_services_dns_stage.py +516 -0
- pulumiverse_scaleway/edge_services_head_stage.py +258 -0
- pulumiverse_scaleway/edge_services_pipeline.py +436 -0
- pulumiverse_scaleway/edge_services_plan.py +239 -0
- pulumiverse_scaleway/edge_services_route_stage.py +422 -0
- pulumiverse_scaleway/edge_services_tls_stage.py +546 -0
- pulumiverse_scaleway/edge_services_waf_stage.py +444 -0
- pulumiverse_scaleway/elasticmetal/ip.py +13 -7
- pulumiverse_scaleway/flexible_ip.py +13 -7
- pulumiverse_scaleway/get_lb_frontend.py +12 -1
- pulumiverse_scaleway/get_lb_route.py +12 -1
- pulumiverse_scaleway/get_secret.py +15 -4
- pulumiverse_scaleway/get_vpc_public_gateway.py +34 -1
- pulumiverse_scaleway/get_vpc_public_gateway_dhcp.py +8 -0
- pulumiverse_scaleway/get_vpc_public_gateway_dhcp_reservation.py +8 -0
- pulumiverse_scaleway/loadbalancer_backend.py +2 -2
- pulumiverse_scaleway/loadbalancer_frontend.py +47 -0
- pulumiverse_scaleway/loadbalancer_route.py +48 -1
- pulumiverse_scaleway/loadbalancers/backend.py +2 -2
- pulumiverse_scaleway/loadbalancers/frontend.py +47 -0
- pulumiverse_scaleway/loadbalancers/get_frontend.py +12 -1
- pulumiverse_scaleway/loadbalancers/get_route.py +12 -1
- pulumiverse_scaleway/loadbalancers/outputs.py +13 -2
- pulumiverse_scaleway/loadbalancers/route.py +48 -1
- pulumiverse_scaleway/network/__init__.py +1 -0
- pulumiverse_scaleway/network/_inputs.py +194 -0
- pulumiverse_scaleway/network/acl.py +415 -0
- pulumiverse_scaleway/network/gateway_network.py +104 -122
- pulumiverse_scaleway/network/get_public_gateway.py +34 -1
- pulumiverse_scaleway/network/get_public_gateway_dhcp.py +8 -0
- pulumiverse_scaleway/network/get_public_gateway_dhcp_reservation.py +8 -0
- pulumiverse_scaleway/network/outputs.py +139 -0
- pulumiverse_scaleway/network/public_gateway.py +124 -21
- pulumiverse_scaleway/network/public_gateway_dhcp.py +8 -0
- pulumiverse_scaleway/network/public_gateway_dhcp_reservation.py +8 -0
- pulumiverse_scaleway/outputs.py +662 -2
- pulumiverse_scaleway/pulumi-plugin.json +1 -1
- pulumiverse_scaleway/secret.py +22 -2
- pulumiverse_scaleway/secret_version.py +6 -6
- pulumiverse_scaleway/secrets/_inputs.py +154 -0
- pulumiverse_scaleway/secrets/get_secret.py +15 -4
- pulumiverse_scaleway/secrets/outputs.py +200 -0
- pulumiverse_scaleway/secrets/secret.py +22 -2
- pulumiverse_scaleway/tem/__init__.py +2 -0
- pulumiverse_scaleway/tem/blocked_list.py +442 -0
- pulumiverse_scaleway/tem/domain.py +7 -0
- pulumiverse_scaleway/tem/get_offer_subscription.py +254 -0
- pulumiverse_scaleway/tem_domain.py +7 -0
- pulumiverse_scaleway/vpc_gateway_network.py +104 -122
- pulumiverse_scaleway/vpc_public_gateway.py +124 -21
- pulumiverse_scaleway/vpc_public_gateway_dhcp.py +8 -0
- pulumiverse_scaleway/vpc_public_gateway_dhcp_reservation.py +8 -0
- {pulumiverse_scaleway-1.26.0a1742897201.dist-info → pulumiverse_scaleway-1.26.0a1743166124.dist-info}/METADATA +1 -1
- {pulumiverse_scaleway-1.26.0a1742897201.dist-info → pulumiverse_scaleway-1.26.0a1743166124.dist-info}/RECORD +66 -53
- {pulumiverse_scaleway-1.26.0a1742897201.dist-info → pulumiverse_scaleway-1.26.0a1743166124.dist-info}/WHEEL +1 -1
- {pulumiverse_scaleway-1.26.0a1742897201.dist-info → pulumiverse_scaleway-1.26.0a1743166124.dist-info}/top_level.txt +0 -0
|
@@ -25,6 +25,62 @@ __all__ = [
|
|
|
25
25
|
'RecordViewArgsDict',
|
|
26
26
|
'RecordWeightedArgs',
|
|
27
27
|
'RecordWeightedArgsDict',
|
|
28
|
+
'RegistrationAdministrativeContactArgs',
|
|
29
|
+
'RegistrationAdministrativeContactArgsDict',
|
|
30
|
+
'RegistrationAdministrativeContactExtensionEuArgs',
|
|
31
|
+
'RegistrationAdministrativeContactExtensionEuArgsDict',
|
|
32
|
+
'RegistrationAdministrativeContactExtensionFrArgs',
|
|
33
|
+
'RegistrationAdministrativeContactExtensionFrArgsDict',
|
|
34
|
+
'RegistrationAdministrativeContactExtensionFrAssociationInfoArgs',
|
|
35
|
+
'RegistrationAdministrativeContactExtensionFrAssociationInfoArgsDict',
|
|
36
|
+
'RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgs',
|
|
37
|
+
'RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgsDict',
|
|
38
|
+
'RegistrationAdministrativeContactExtensionFrDunsInfoArgs',
|
|
39
|
+
'RegistrationAdministrativeContactExtensionFrDunsInfoArgsDict',
|
|
40
|
+
'RegistrationAdministrativeContactExtensionFrIndividualInfoArgs',
|
|
41
|
+
'RegistrationAdministrativeContactExtensionFrIndividualInfoArgsDict',
|
|
42
|
+
'RegistrationAdministrativeContactExtensionFrTrademarkInfoArgs',
|
|
43
|
+
'RegistrationAdministrativeContactExtensionFrTrademarkInfoArgsDict',
|
|
44
|
+
'RegistrationDsRecordArgs',
|
|
45
|
+
'RegistrationDsRecordArgsDict',
|
|
46
|
+
'RegistrationDsRecordDigestArgs',
|
|
47
|
+
'RegistrationDsRecordDigestArgsDict',
|
|
48
|
+
'RegistrationDsRecordDigestPublicKeyArgs',
|
|
49
|
+
'RegistrationDsRecordDigestPublicKeyArgsDict',
|
|
50
|
+
'RegistrationDsRecordPublicKeyArgs',
|
|
51
|
+
'RegistrationDsRecordPublicKeyArgsDict',
|
|
52
|
+
'RegistrationOwnerContactArgs',
|
|
53
|
+
'RegistrationOwnerContactArgsDict',
|
|
54
|
+
'RegistrationOwnerContactExtensionEuArgs',
|
|
55
|
+
'RegistrationOwnerContactExtensionEuArgsDict',
|
|
56
|
+
'RegistrationOwnerContactExtensionFrArgs',
|
|
57
|
+
'RegistrationOwnerContactExtensionFrArgsDict',
|
|
58
|
+
'RegistrationOwnerContactExtensionFrAssociationInfoArgs',
|
|
59
|
+
'RegistrationOwnerContactExtensionFrAssociationInfoArgsDict',
|
|
60
|
+
'RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgs',
|
|
61
|
+
'RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgsDict',
|
|
62
|
+
'RegistrationOwnerContactExtensionFrDunsInfoArgs',
|
|
63
|
+
'RegistrationOwnerContactExtensionFrDunsInfoArgsDict',
|
|
64
|
+
'RegistrationOwnerContactExtensionFrIndividualInfoArgs',
|
|
65
|
+
'RegistrationOwnerContactExtensionFrIndividualInfoArgsDict',
|
|
66
|
+
'RegistrationOwnerContactExtensionFrTrademarkInfoArgs',
|
|
67
|
+
'RegistrationOwnerContactExtensionFrTrademarkInfoArgsDict',
|
|
68
|
+
'RegistrationTechnicalContactArgs',
|
|
69
|
+
'RegistrationTechnicalContactArgsDict',
|
|
70
|
+
'RegistrationTechnicalContactExtensionEuArgs',
|
|
71
|
+
'RegistrationTechnicalContactExtensionEuArgsDict',
|
|
72
|
+
'RegistrationTechnicalContactExtensionFrArgs',
|
|
73
|
+
'RegistrationTechnicalContactExtensionFrArgsDict',
|
|
74
|
+
'RegistrationTechnicalContactExtensionFrAssociationInfoArgs',
|
|
75
|
+
'RegistrationTechnicalContactExtensionFrAssociationInfoArgsDict',
|
|
76
|
+
'RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgs',
|
|
77
|
+
'RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgsDict',
|
|
78
|
+
'RegistrationTechnicalContactExtensionFrDunsInfoArgs',
|
|
79
|
+
'RegistrationTechnicalContactExtensionFrDunsInfoArgsDict',
|
|
80
|
+
'RegistrationTechnicalContactExtensionFrIndividualInfoArgs',
|
|
81
|
+
'RegistrationTechnicalContactExtensionFrIndividualInfoArgsDict',
|
|
82
|
+
'RegistrationTechnicalContactExtensionFrTrademarkInfoArgs',
|
|
83
|
+
'RegistrationTechnicalContactExtensionFrTrademarkInfoArgsDict',
|
|
28
84
|
]
|
|
29
85
|
|
|
30
86
|
MYPY = False
|
|
@@ -339,3 +395,2644 @@ class RecordWeightedArgs:
|
|
|
339
395
|
pulumi.set(self, "weight", value)
|
|
340
396
|
|
|
341
397
|
|
|
398
|
+
if not MYPY:
|
|
399
|
+
class RegistrationAdministrativeContactArgsDict(TypedDict):
|
|
400
|
+
address_line1: pulumi.Input[str]
|
|
401
|
+
"""
|
|
402
|
+
Primary address line for the contact.
|
|
403
|
+
"""
|
|
404
|
+
city: pulumi.Input[str]
|
|
405
|
+
"""
|
|
406
|
+
City of the contact's address.
|
|
407
|
+
"""
|
|
408
|
+
company_identification_code: pulumi.Input[str]
|
|
409
|
+
"""
|
|
410
|
+
Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
411
|
+
"""
|
|
412
|
+
country: pulumi.Input[str]
|
|
413
|
+
"""
|
|
414
|
+
Country code of the contact's address (ISO format).
|
|
415
|
+
"""
|
|
416
|
+
email: pulumi.Input[str]
|
|
417
|
+
"""
|
|
418
|
+
Primary email address of the contact.
|
|
419
|
+
"""
|
|
420
|
+
firstname: pulumi.Input[str]
|
|
421
|
+
"""
|
|
422
|
+
First name of the contact.
|
|
423
|
+
"""
|
|
424
|
+
lastname: pulumi.Input[str]
|
|
425
|
+
"""
|
|
426
|
+
Last name of the contact.
|
|
427
|
+
"""
|
|
428
|
+
legal_form: pulumi.Input[str]
|
|
429
|
+
"""
|
|
430
|
+
Legal form of the contact (e.g., 'individual' or 'organization').
|
|
431
|
+
"""
|
|
432
|
+
phone_number: pulumi.Input[str]
|
|
433
|
+
"""
|
|
434
|
+
Primary phone number of the contact.
|
|
435
|
+
"""
|
|
436
|
+
vat_identification_code: pulumi.Input[str]
|
|
437
|
+
"""
|
|
438
|
+
VAT identification code of the contact, if applicable.
|
|
439
|
+
"""
|
|
440
|
+
zip: pulumi.Input[str]
|
|
441
|
+
"""
|
|
442
|
+
Postal code of the contact's address.
|
|
443
|
+
"""
|
|
444
|
+
address_line2: NotRequired[pulumi.Input[str]]
|
|
445
|
+
"""
|
|
446
|
+
Secondary address line for the contact (optional).
|
|
447
|
+
"""
|
|
448
|
+
company_name: NotRequired[pulumi.Input[str]]
|
|
449
|
+
"""
|
|
450
|
+
Name of the company associated with the contact (if applicable).
|
|
451
|
+
"""
|
|
452
|
+
email_alt: NotRequired[pulumi.Input[str]]
|
|
453
|
+
"""
|
|
454
|
+
Alternative email address for the contact.
|
|
455
|
+
"""
|
|
456
|
+
extension_eu: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionEuArgsDict']]
|
|
457
|
+
"""
|
|
458
|
+
Details specific to European domain extensions.
|
|
459
|
+
"""
|
|
460
|
+
extension_fr: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionFrArgsDict']]
|
|
461
|
+
"""
|
|
462
|
+
Details specific to French domain extensions.
|
|
463
|
+
"""
|
|
464
|
+
extension_nls: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
465
|
+
"""
|
|
466
|
+
Extension details specific to Dutch domain registrations.
|
|
467
|
+
"""
|
|
468
|
+
fax_number: NotRequired[pulumi.Input[str]]
|
|
469
|
+
"""
|
|
470
|
+
Fax number for the contact (if available).
|
|
471
|
+
"""
|
|
472
|
+
lang: NotRequired[pulumi.Input[str]]
|
|
473
|
+
"""
|
|
474
|
+
Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
475
|
+
"""
|
|
476
|
+
resale: NotRequired[pulumi.Input[bool]]
|
|
477
|
+
"""
|
|
478
|
+
Indicates if the contact is used for resale purposes.
|
|
479
|
+
"""
|
|
480
|
+
state: NotRequired[pulumi.Input[str]]
|
|
481
|
+
"""
|
|
482
|
+
State or region of the contact.
|
|
483
|
+
"""
|
|
484
|
+
whois_opt_in: NotRequired[pulumi.Input[bool]]
|
|
485
|
+
"""
|
|
486
|
+
Indicates whether the contact has opted into WHOIS publishing.
|
|
487
|
+
"""
|
|
488
|
+
elif False:
|
|
489
|
+
RegistrationAdministrativeContactArgsDict: TypeAlias = Mapping[str, Any]
|
|
490
|
+
|
|
491
|
+
@pulumi.input_type
|
|
492
|
+
class RegistrationAdministrativeContactArgs:
|
|
493
|
+
def __init__(__self__, *,
|
|
494
|
+
address_line1: pulumi.Input[str],
|
|
495
|
+
city: pulumi.Input[str],
|
|
496
|
+
company_identification_code: pulumi.Input[str],
|
|
497
|
+
country: pulumi.Input[str],
|
|
498
|
+
email: pulumi.Input[str],
|
|
499
|
+
firstname: pulumi.Input[str],
|
|
500
|
+
lastname: pulumi.Input[str],
|
|
501
|
+
legal_form: pulumi.Input[str],
|
|
502
|
+
phone_number: pulumi.Input[str],
|
|
503
|
+
vat_identification_code: pulumi.Input[str],
|
|
504
|
+
zip: pulumi.Input[str],
|
|
505
|
+
address_line2: Optional[pulumi.Input[str]] = None,
|
|
506
|
+
company_name: Optional[pulumi.Input[str]] = None,
|
|
507
|
+
email_alt: Optional[pulumi.Input[str]] = None,
|
|
508
|
+
extension_eu: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionEuArgs']] = None,
|
|
509
|
+
extension_fr: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrArgs']] = None,
|
|
510
|
+
extension_nls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
511
|
+
fax_number: Optional[pulumi.Input[str]] = None,
|
|
512
|
+
lang: Optional[pulumi.Input[str]] = None,
|
|
513
|
+
resale: Optional[pulumi.Input[bool]] = None,
|
|
514
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
515
|
+
whois_opt_in: Optional[pulumi.Input[bool]] = None):
|
|
516
|
+
"""
|
|
517
|
+
:param pulumi.Input[str] address_line1: Primary address line for the contact.
|
|
518
|
+
:param pulumi.Input[str] city: City of the contact's address.
|
|
519
|
+
:param pulumi.Input[str] company_identification_code: Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
520
|
+
:param pulumi.Input[str] country: Country code of the contact's address (ISO format).
|
|
521
|
+
:param pulumi.Input[str] email: Primary email address of the contact.
|
|
522
|
+
:param pulumi.Input[str] firstname: First name of the contact.
|
|
523
|
+
:param pulumi.Input[str] lastname: Last name of the contact.
|
|
524
|
+
:param pulumi.Input[str] legal_form: Legal form of the contact (e.g., 'individual' or 'organization').
|
|
525
|
+
:param pulumi.Input[str] phone_number: Primary phone number of the contact.
|
|
526
|
+
:param pulumi.Input[str] vat_identification_code: VAT identification code of the contact, if applicable.
|
|
527
|
+
:param pulumi.Input[str] zip: Postal code of the contact's address.
|
|
528
|
+
:param pulumi.Input[str] address_line2: Secondary address line for the contact (optional).
|
|
529
|
+
:param pulumi.Input[str] company_name: Name of the company associated with the contact (if applicable).
|
|
530
|
+
:param pulumi.Input[str] email_alt: Alternative email address for the contact.
|
|
531
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionEuArgs'] extension_eu: Details specific to European domain extensions.
|
|
532
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionFrArgs'] extension_fr: Details specific to French domain extensions.
|
|
533
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] extension_nls: Extension details specific to Dutch domain registrations.
|
|
534
|
+
:param pulumi.Input[str] fax_number: Fax number for the contact (if available).
|
|
535
|
+
:param pulumi.Input[str] lang: Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
536
|
+
:param pulumi.Input[bool] resale: Indicates if the contact is used for resale purposes.
|
|
537
|
+
:param pulumi.Input[str] state: State or region of the contact.
|
|
538
|
+
:param pulumi.Input[bool] whois_opt_in: Indicates whether the contact has opted into WHOIS publishing.
|
|
539
|
+
"""
|
|
540
|
+
pulumi.set(__self__, "address_line1", address_line1)
|
|
541
|
+
pulumi.set(__self__, "city", city)
|
|
542
|
+
pulumi.set(__self__, "company_identification_code", company_identification_code)
|
|
543
|
+
pulumi.set(__self__, "country", country)
|
|
544
|
+
pulumi.set(__self__, "email", email)
|
|
545
|
+
pulumi.set(__self__, "firstname", firstname)
|
|
546
|
+
pulumi.set(__self__, "lastname", lastname)
|
|
547
|
+
pulumi.set(__self__, "legal_form", legal_form)
|
|
548
|
+
pulumi.set(__self__, "phone_number", phone_number)
|
|
549
|
+
pulumi.set(__self__, "vat_identification_code", vat_identification_code)
|
|
550
|
+
pulumi.set(__self__, "zip", zip)
|
|
551
|
+
if address_line2 is not None:
|
|
552
|
+
pulumi.set(__self__, "address_line2", address_line2)
|
|
553
|
+
if company_name is not None:
|
|
554
|
+
pulumi.set(__self__, "company_name", company_name)
|
|
555
|
+
if email_alt is not None:
|
|
556
|
+
pulumi.set(__self__, "email_alt", email_alt)
|
|
557
|
+
if extension_eu is not None:
|
|
558
|
+
pulumi.set(__self__, "extension_eu", extension_eu)
|
|
559
|
+
if extension_fr is not None:
|
|
560
|
+
pulumi.set(__self__, "extension_fr", extension_fr)
|
|
561
|
+
if extension_nls is not None:
|
|
562
|
+
pulumi.set(__self__, "extension_nls", extension_nls)
|
|
563
|
+
if fax_number is not None:
|
|
564
|
+
pulumi.set(__self__, "fax_number", fax_number)
|
|
565
|
+
if lang is not None:
|
|
566
|
+
pulumi.set(__self__, "lang", lang)
|
|
567
|
+
if resale is not None:
|
|
568
|
+
pulumi.set(__self__, "resale", resale)
|
|
569
|
+
if state is not None:
|
|
570
|
+
pulumi.set(__self__, "state", state)
|
|
571
|
+
if whois_opt_in is not None:
|
|
572
|
+
pulumi.set(__self__, "whois_opt_in", whois_opt_in)
|
|
573
|
+
|
|
574
|
+
@property
|
|
575
|
+
@pulumi.getter(name="addressLine1")
|
|
576
|
+
def address_line1(self) -> pulumi.Input[str]:
|
|
577
|
+
"""
|
|
578
|
+
Primary address line for the contact.
|
|
579
|
+
"""
|
|
580
|
+
return pulumi.get(self, "address_line1")
|
|
581
|
+
|
|
582
|
+
@address_line1.setter
|
|
583
|
+
def address_line1(self, value: pulumi.Input[str]):
|
|
584
|
+
pulumi.set(self, "address_line1", value)
|
|
585
|
+
|
|
586
|
+
@property
|
|
587
|
+
@pulumi.getter
|
|
588
|
+
def city(self) -> pulumi.Input[str]:
|
|
589
|
+
"""
|
|
590
|
+
City of the contact's address.
|
|
591
|
+
"""
|
|
592
|
+
return pulumi.get(self, "city")
|
|
593
|
+
|
|
594
|
+
@city.setter
|
|
595
|
+
def city(self, value: pulumi.Input[str]):
|
|
596
|
+
pulumi.set(self, "city", value)
|
|
597
|
+
|
|
598
|
+
@property
|
|
599
|
+
@pulumi.getter(name="companyIdentificationCode")
|
|
600
|
+
def company_identification_code(self) -> pulumi.Input[str]:
|
|
601
|
+
"""
|
|
602
|
+
Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
603
|
+
"""
|
|
604
|
+
return pulumi.get(self, "company_identification_code")
|
|
605
|
+
|
|
606
|
+
@company_identification_code.setter
|
|
607
|
+
def company_identification_code(self, value: pulumi.Input[str]):
|
|
608
|
+
pulumi.set(self, "company_identification_code", value)
|
|
609
|
+
|
|
610
|
+
@property
|
|
611
|
+
@pulumi.getter
|
|
612
|
+
def country(self) -> pulumi.Input[str]:
|
|
613
|
+
"""
|
|
614
|
+
Country code of the contact's address (ISO format).
|
|
615
|
+
"""
|
|
616
|
+
return pulumi.get(self, "country")
|
|
617
|
+
|
|
618
|
+
@country.setter
|
|
619
|
+
def country(self, value: pulumi.Input[str]):
|
|
620
|
+
pulumi.set(self, "country", value)
|
|
621
|
+
|
|
622
|
+
@property
|
|
623
|
+
@pulumi.getter
|
|
624
|
+
def email(self) -> pulumi.Input[str]:
|
|
625
|
+
"""
|
|
626
|
+
Primary email address of the contact.
|
|
627
|
+
"""
|
|
628
|
+
return pulumi.get(self, "email")
|
|
629
|
+
|
|
630
|
+
@email.setter
|
|
631
|
+
def email(self, value: pulumi.Input[str]):
|
|
632
|
+
pulumi.set(self, "email", value)
|
|
633
|
+
|
|
634
|
+
@property
|
|
635
|
+
@pulumi.getter
|
|
636
|
+
def firstname(self) -> pulumi.Input[str]:
|
|
637
|
+
"""
|
|
638
|
+
First name of the contact.
|
|
639
|
+
"""
|
|
640
|
+
return pulumi.get(self, "firstname")
|
|
641
|
+
|
|
642
|
+
@firstname.setter
|
|
643
|
+
def firstname(self, value: pulumi.Input[str]):
|
|
644
|
+
pulumi.set(self, "firstname", value)
|
|
645
|
+
|
|
646
|
+
@property
|
|
647
|
+
@pulumi.getter
|
|
648
|
+
def lastname(self) -> pulumi.Input[str]:
|
|
649
|
+
"""
|
|
650
|
+
Last name of the contact.
|
|
651
|
+
"""
|
|
652
|
+
return pulumi.get(self, "lastname")
|
|
653
|
+
|
|
654
|
+
@lastname.setter
|
|
655
|
+
def lastname(self, value: pulumi.Input[str]):
|
|
656
|
+
pulumi.set(self, "lastname", value)
|
|
657
|
+
|
|
658
|
+
@property
|
|
659
|
+
@pulumi.getter(name="legalForm")
|
|
660
|
+
def legal_form(self) -> pulumi.Input[str]:
|
|
661
|
+
"""
|
|
662
|
+
Legal form of the contact (e.g., 'individual' or 'organization').
|
|
663
|
+
"""
|
|
664
|
+
return pulumi.get(self, "legal_form")
|
|
665
|
+
|
|
666
|
+
@legal_form.setter
|
|
667
|
+
def legal_form(self, value: pulumi.Input[str]):
|
|
668
|
+
pulumi.set(self, "legal_form", value)
|
|
669
|
+
|
|
670
|
+
@property
|
|
671
|
+
@pulumi.getter(name="phoneNumber")
|
|
672
|
+
def phone_number(self) -> pulumi.Input[str]:
|
|
673
|
+
"""
|
|
674
|
+
Primary phone number of the contact.
|
|
675
|
+
"""
|
|
676
|
+
return pulumi.get(self, "phone_number")
|
|
677
|
+
|
|
678
|
+
@phone_number.setter
|
|
679
|
+
def phone_number(self, value: pulumi.Input[str]):
|
|
680
|
+
pulumi.set(self, "phone_number", value)
|
|
681
|
+
|
|
682
|
+
@property
|
|
683
|
+
@pulumi.getter(name="vatIdentificationCode")
|
|
684
|
+
def vat_identification_code(self) -> pulumi.Input[str]:
|
|
685
|
+
"""
|
|
686
|
+
VAT identification code of the contact, if applicable.
|
|
687
|
+
"""
|
|
688
|
+
return pulumi.get(self, "vat_identification_code")
|
|
689
|
+
|
|
690
|
+
@vat_identification_code.setter
|
|
691
|
+
def vat_identification_code(self, value: pulumi.Input[str]):
|
|
692
|
+
pulumi.set(self, "vat_identification_code", value)
|
|
693
|
+
|
|
694
|
+
@property
|
|
695
|
+
@pulumi.getter
|
|
696
|
+
def zip(self) -> pulumi.Input[str]:
|
|
697
|
+
"""
|
|
698
|
+
Postal code of the contact's address.
|
|
699
|
+
"""
|
|
700
|
+
return pulumi.get(self, "zip")
|
|
701
|
+
|
|
702
|
+
@zip.setter
|
|
703
|
+
def zip(self, value: pulumi.Input[str]):
|
|
704
|
+
pulumi.set(self, "zip", value)
|
|
705
|
+
|
|
706
|
+
@property
|
|
707
|
+
@pulumi.getter(name="addressLine2")
|
|
708
|
+
def address_line2(self) -> Optional[pulumi.Input[str]]:
|
|
709
|
+
"""
|
|
710
|
+
Secondary address line for the contact (optional).
|
|
711
|
+
"""
|
|
712
|
+
return pulumi.get(self, "address_line2")
|
|
713
|
+
|
|
714
|
+
@address_line2.setter
|
|
715
|
+
def address_line2(self, value: Optional[pulumi.Input[str]]):
|
|
716
|
+
pulumi.set(self, "address_line2", value)
|
|
717
|
+
|
|
718
|
+
@property
|
|
719
|
+
@pulumi.getter(name="companyName")
|
|
720
|
+
def company_name(self) -> Optional[pulumi.Input[str]]:
|
|
721
|
+
"""
|
|
722
|
+
Name of the company associated with the contact (if applicable).
|
|
723
|
+
"""
|
|
724
|
+
return pulumi.get(self, "company_name")
|
|
725
|
+
|
|
726
|
+
@company_name.setter
|
|
727
|
+
def company_name(self, value: Optional[pulumi.Input[str]]):
|
|
728
|
+
pulumi.set(self, "company_name", value)
|
|
729
|
+
|
|
730
|
+
@property
|
|
731
|
+
@pulumi.getter(name="emailAlt")
|
|
732
|
+
def email_alt(self) -> Optional[pulumi.Input[str]]:
|
|
733
|
+
"""
|
|
734
|
+
Alternative email address for the contact.
|
|
735
|
+
"""
|
|
736
|
+
return pulumi.get(self, "email_alt")
|
|
737
|
+
|
|
738
|
+
@email_alt.setter
|
|
739
|
+
def email_alt(self, value: Optional[pulumi.Input[str]]):
|
|
740
|
+
pulumi.set(self, "email_alt", value)
|
|
741
|
+
|
|
742
|
+
@property
|
|
743
|
+
@pulumi.getter(name="extensionEu")
|
|
744
|
+
def extension_eu(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionEuArgs']]:
|
|
745
|
+
"""
|
|
746
|
+
Details specific to European domain extensions.
|
|
747
|
+
"""
|
|
748
|
+
return pulumi.get(self, "extension_eu")
|
|
749
|
+
|
|
750
|
+
@extension_eu.setter
|
|
751
|
+
def extension_eu(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionEuArgs']]):
|
|
752
|
+
pulumi.set(self, "extension_eu", value)
|
|
753
|
+
|
|
754
|
+
@property
|
|
755
|
+
@pulumi.getter(name="extensionFr")
|
|
756
|
+
def extension_fr(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrArgs']]:
|
|
757
|
+
"""
|
|
758
|
+
Details specific to French domain extensions.
|
|
759
|
+
"""
|
|
760
|
+
return pulumi.get(self, "extension_fr")
|
|
761
|
+
|
|
762
|
+
@extension_fr.setter
|
|
763
|
+
def extension_fr(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrArgs']]):
|
|
764
|
+
pulumi.set(self, "extension_fr", value)
|
|
765
|
+
|
|
766
|
+
@property
|
|
767
|
+
@pulumi.getter(name="extensionNls")
|
|
768
|
+
def extension_nls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
769
|
+
"""
|
|
770
|
+
Extension details specific to Dutch domain registrations.
|
|
771
|
+
"""
|
|
772
|
+
return pulumi.get(self, "extension_nls")
|
|
773
|
+
|
|
774
|
+
@extension_nls.setter
|
|
775
|
+
def extension_nls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
776
|
+
pulumi.set(self, "extension_nls", value)
|
|
777
|
+
|
|
778
|
+
@property
|
|
779
|
+
@pulumi.getter(name="faxNumber")
|
|
780
|
+
def fax_number(self) -> Optional[pulumi.Input[str]]:
|
|
781
|
+
"""
|
|
782
|
+
Fax number for the contact (if available).
|
|
783
|
+
"""
|
|
784
|
+
return pulumi.get(self, "fax_number")
|
|
785
|
+
|
|
786
|
+
@fax_number.setter
|
|
787
|
+
def fax_number(self, value: Optional[pulumi.Input[str]]):
|
|
788
|
+
pulumi.set(self, "fax_number", value)
|
|
789
|
+
|
|
790
|
+
@property
|
|
791
|
+
@pulumi.getter
|
|
792
|
+
def lang(self) -> Optional[pulumi.Input[str]]:
|
|
793
|
+
"""
|
|
794
|
+
Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
795
|
+
"""
|
|
796
|
+
return pulumi.get(self, "lang")
|
|
797
|
+
|
|
798
|
+
@lang.setter
|
|
799
|
+
def lang(self, value: Optional[pulumi.Input[str]]):
|
|
800
|
+
pulumi.set(self, "lang", value)
|
|
801
|
+
|
|
802
|
+
@property
|
|
803
|
+
@pulumi.getter
|
|
804
|
+
def resale(self) -> Optional[pulumi.Input[bool]]:
|
|
805
|
+
"""
|
|
806
|
+
Indicates if the contact is used for resale purposes.
|
|
807
|
+
"""
|
|
808
|
+
return pulumi.get(self, "resale")
|
|
809
|
+
|
|
810
|
+
@resale.setter
|
|
811
|
+
def resale(self, value: Optional[pulumi.Input[bool]]):
|
|
812
|
+
pulumi.set(self, "resale", value)
|
|
813
|
+
|
|
814
|
+
@property
|
|
815
|
+
@pulumi.getter
|
|
816
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
817
|
+
"""
|
|
818
|
+
State or region of the contact.
|
|
819
|
+
"""
|
|
820
|
+
return pulumi.get(self, "state")
|
|
821
|
+
|
|
822
|
+
@state.setter
|
|
823
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
824
|
+
pulumi.set(self, "state", value)
|
|
825
|
+
|
|
826
|
+
@property
|
|
827
|
+
@pulumi.getter(name="whoisOptIn")
|
|
828
|
+
def whois_opt_in(self) -> Optional[pulumi.Input[bool]]:
|
|
829
|
+
"""
|
|
830
|
+
Indicates whether the contact has opted into WHOIS publishing.
|
|
831
|
+
"""
|
|
832
|
+
return pulumi.get(self, "whois_opt_in")
|
|
833
|
+
|
|
834
|
+
@whois_opt_in.setter
|
|
835
|
+
def whois_opt_in(self, value: Optional[pulumi.Input[bool]]):
|
|
836
|
+
pulumi.set(self, "whois_opt_in", value)
|
|
837
|
+
|
|
838
|
+
|
|
839
|
+
if not MYPY:
|
|
840
|
+
class RegistrationAdministrativeContactExtensionEuArgsDict(TypedDict):
|
|
841
|
+
european_citizenship: NotRequired[pulumi.Input[str]]
|
|
842
|
+
"""
|
|
843
|
+
Indicates the European citizenship of the contact.
|
|
844
|
+
"""
|
|
845
|
+
elif False:
|
|
846
|
+
RegistrationAdministrativeContactExtensionEuArgsDict: TypeAlias = Mapping[str, Any]
|
|
847
|
+
|
|
848
|
+
@pulumi.input_type
|
|
849
|
+
class RegistrationAdministrativeContactExtensionEuArgs:
|
|
850
|
+
def __init__(__self__, *,
|
|
851
|
+
european_citizenship: Optional[pulumi.Input[str]] = None):
|
|
852
|
+
"""
|
|
853
|
+
:param pulumi.Input[str] european_citizenship: Indicates the European citizenship of the contact.
|
|
854
|
+
"""
|
|
855
|
+
if european_citizenship is not None:
|
|
856
|
+
pulumi.set(__self__, "european_citizenship", european_citizenship)
|
|
857
|
+
|
|
858
|
+
@property
|
|
859
|
+
@pulumi.getter(name="europeanCitizenship")
|
|
860
|
+
def european_citizenship(self) -> Optional[pulumi.Input[str]]:
|
|
861
|
+
"""
|
|
862
|
+
Indicates the European citizenship of the contact.
|
|
863
|
+
"""
|
|
864
|
+
return pulumi.get(self, "european_citizenship")
|
|
865
|
+
|
|
866
|
+
@european_citizenship.setter
|
|
867
|
+
def european_citizenship(self, value: Optional[pulumi.Input[str]]):
|
|
868
|
+
pulumi.set(self, "european_citizenship", value)
|
|
869
|
+
|
|
870
|
+
|
|
871
|
+
if not MYPY:
|
|
872
|
+
class RegistrationAdministrativeContactExtensionFrArgsDict(TypedDict):
|
|
873
|
+
association_info: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionFrAssociationInfoArgsDict']]
|
|
874
|
+
"""
|
|
875
|
+
Association-specific information for the domain (French extension).
|
|
876
|
+
"""
|
|
877
|
+
code_auth_afnic_info: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgsDict']]
|
|
878
|
+
"""
|
|
879
|
+
AFNIC authorization information for the contact (French extension).
|
|
880
|
+
"""
|
|
881
|
+
duns_info: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionFrDunsInfoArgsDict']]
|
|
882
|
+
"""
|
|
883
|
+
DUNS information for the domain owner (specific to French domains).
|
|
884
|
+
"""
|
|
885
|
+
individual_info: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionFrIndividualInfoArgsDict']]
|
|
886
|
+
"""
|
|
887
|
+
Information about the individual registration for French domains.
|
|
888
|
+
"""
|
|
889
|
+
mode: NotRequired[pulumi.Input[str]]
|
|
890
|
+
"""
|
|
891
|
+
Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
892
|
+
"""
|
|
893
|
+
trademark_info: NotRequired[pulumi.Input['RegistrationAdministrativeContactExtensionFrTrademarkInfoArgsDict']]
|
|
894
|
+
"""
|
|
895
|
+
Trademark-related information for the domain (French extension).
|
|
896
|
+
"""
|
|
897
|
+
elif False:
|
|
898
|
+
RegistrationAdministrativeContactExtensionFrArgsDict: TypeAlias = Mapping[str, Any]
|
|
899
|
+
|
|
900
|
+
@pulumi.input_type
|
|
901
|
+
class RegistrationAdministrativeContactExtensionFrArgs:
|
|
902
|
+
def __init__(__self__, *,
|
|
903
|
+
association_info: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrAssociationInfoArgs']] = None,
|
|
904
|
+
code_auth_afnic_info: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgs']] = None,
|
|
905
|
+
duns_info: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrDunsInfoArgs']] = None,
|
|
906
|
+
individual_info: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrIndividualInfoArgs']] = None,
|
|
907
|
+
mode: Optional[pulumi.Input[str]] = None,
|
|
908
|
+
trademark_info: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrTrademarkInfoArgs']] = None):
|
|
909
|
+
"""
|
|
910
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionFrAssociationInfoArgs'] association_info: Association-specific information for the domain (French extension).
|
|
911
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgs'] code_auth_afnic_info: AFNIC authorization information for the contact (French extension).
|
|
912
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionFrDunsInfoArgs'] duns_info: DUNS information for the domain owner (specific to French domains).
|
|
913
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionFrIndividualInfoArgs'] individual_info: Information about the individual registration for French domains.
|
|
914
|
+
:param pulumi.Input[str] mode: Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
915
|
+
:param pulumi.Input['RegistrationAdministrativeContactExtensionFrTrademarkInfoArgs'] trademark_info: Trademark-related information for the domain (French extension).
|
|
916
|
+
"""
|
|
917
|
+
if association_info is not None:
|
|
918
|
+
pulumi.set(__self__, "association_info", association_info)
|
|
919
|
+
if code_auth_afnic_info is not None:
|
|
920
|
+
pulumi.set(__self__, "code_auth_afnic_info", code_auth_afnic_info)
|
|
921
|
+
if duns_info is not None:
|
|
922
|
+
pulumi.set(__self__, "duns_info", duns_info)
|
|
923
|
+
if individual_info is not None:
|
|
924
|
+
pulumi.set(__self__, "individual_info", individual_info)
|
|
925
|
+
if mode is not None:
|
|
926
|
+
pulumi.set(__self__, "mode", mode)
|
|
927
|
+
if trademark_info is not None:
|
|
928
|
+
pulumi.set(__self__, "trademark_info", trademark_info)
|
|
929
|
+
|
|
930
|
+
@property
|
|
931
|
+
@pulumi.getter(name="associationInfo")
|
|
932
|
+
def association_info(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrAssociationInfoArgs']]:
|
|
933
|
+
"""
|
|
934
|
+
Association-specific information for the domain (French extension).
|
|
935
|
+
"""
|
|
936
|
+
return pulumi.get(self, "association_info")
|
|
937
|
+
|
|
938
|
+
@association_info.setter
|
|
939
|
+
def association_info(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrAssociationInfoArgs']]):
|
|
940
|
+
pulumi.set(self, "association_info", value)
|
|
941
|
+
|
|
942
|
+
@property
|
|
943
|
+
@pulumi.getter(name="codeAuthAfnicInfo")
|
|
944
|
+
def code_auth_afnic_info(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgs']]:
|
|
945
|
+
"""
|
|
946
|
+
AFNIC authorization information for the contact (French extension).
|
|
947
|
+
"""
|
|
948
|
+
return pulumi.get(self, "code_auth_afnic_info")
|
|
949
|
+
|
|
950
|
+
@code_auth_afnic_info.setter
|
|
951
|
+
def code_auth_afnic_info(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgs']]):
|
|
952
|
+
pulumi.set(self, "code_auth_afnic_info", value)
|
|
953
|
+
|
|
954
|
+
@property
|
|
955
|
+
@pulumi.getter(name="dunsInfo")
|
|
956
|
+
def duns_info(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrDunsInfoArgs']]:
|
|
957
|
+
"""
|
|
958
|
+
DUNS information for the domain owner (specific to French domains).
|
|
959
|
+
"""
|
|
960
|
+
return pulumi.get(self, "duns_info")
|
|
961
|
+
|
|
962
|
+
@duns_info.setter
|
|
963
|
+
def duns_info(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrDunsInfoArgs']]):
|
|
964
|
+
pulumi.set(self, "duns_info", value)
|
|
965
|
+
|
|
966
|
+
@property
|
|
967
|
+
@pulumi.getter(name="individualInfo")
|
|
968
|
+
def individual_info(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrIndividualInfoArgs']]:
|
|
969
|
+
"""
|
|
970
|
+
Information about the individual registration for French domains.
|
|
971
|
+
"""
|
|
972
|
+
return pulumi.get(self, "individual_info")
|
|
973
|
+
|
|
974
|
+
@individual_info.setter
|
|
975
|
+
def individual_info(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrIndividualInfoArgs']]):
|
|
976
|
+
pulumi.set(self, "individual_info", value)
|
|
977
|
+
|
|
978
|
+
@property
|
|
979
|
+
@pulumi.getter
|
|
980
|
+
def mode(self) -> Optional[pulumi.Input[str]]:
|
|
981
|
+
"""
|
|
982
|
+
Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
983
|
+
"""
|
|
984
|
+
return pulumi.get(self, "mode")
|
|
985
|
+
|
|
986
|
+
@mode.setter
|
|
987
|
+
def mode(self, value: Optional[pulumi.Input[str]]):
|
|
988
|
+
pulumi.set(self, "mode", value)
|
|
989
|
+
|
|
990
|
+
@property
|
|
991
|
+
@pulumi.getter(name="trademarkInfo")
|
|
992
|
+
def trademark_info(self) -> Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrTrademarkInfoArgs']]:
|
|
993
|
+
"""
|
|
994
|
+
Trademark-related information for the domain (French extension).
|
|
995
|
+
"""
|
|
996
|
+
return pulumi.get(self, "trademark_info")
|
|
997
|
+
|
|
998
|
+
@trademark_info.setter
|
|
999
|
+
def trademark_info(self, value: Optional[pulumi.Input['RegistrationAdministrativeContactExtensionFrTrademarkInfoArgs']]):
|
|
1000
|
+
pulumi.set(self, "trademark_info", value)
|
|
1001
|
+
|
|
1002
|
+
|
|
1003
|
+
if not MYPY:
|
|
1004
|
+
class RegistrationAdministrativeContactExtensionFrAssociationInfoArgsDict(TypedDict):
|
|
1005
|
+
publication_jo: NotRequired[pulumi.Input[str]]
|
|
1006
|
+
"""
|
|
1007
|
+
Publication date in the Official Journal (RFC3339 format) for association information.
|
|
1008
|
+
"""
|
|
1009
|
+
publication_jo_page: NotRequired[pulumi.Input[int]]
|
|
1010
|
+
"""
|
|
1011
|
+
Page number of the publication in the Official Journal for association information.
|
|
1012
|
+
"""
|
|
1013
|
+
elif False:
|
|
1014
|
+
RegistrationAdministrativeContactExtensionFrAssociationInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
1015
|
+
|
|
1016
|
+
@pulumi.input_type
|
|
1017
|
+
class RegistrationAdministrativeContactExtensionFrAssociationInfoArgs:
|
|
1018
|
+
def __init__(__self__, *,
|
|
1019
|
+
publication_jo: Optional[pulumi.Input[str]] = None,
|
|
1020
|
+
publication_jo_page: Optional[pulumi.Input[int]] = None):
|
|
1021
|
+
"""
|
|
1022
|
+
:param pulumi.Input[str] publication_jo: Publication date in the Official Journal (RFC3339 format) for association information.
|
|
1023
|
+
:param pulumi.Input[int] publication_jo_page: Page number of the publication in the Official Journal for association information.
|
|
1024
|
+
"""
|
|
1025
|
+
if publication_jo is not None:
|
|
1026
|
+
pulumi.set(__self__, "publication_jo", publication_jo)
|
|
1027
|
+
if publication_jo_page is not None:
|
|
1028
|
+
pulumi.set(__self__, "publication_jo_page", publication_jo_page)
|
|
1029
|
+
|
|
1030
|
+
@property
|
|
1031
|
+
@pulumi.getter(name="publicationJo")
|
|
1032
|
+
def publication_jo(self) -> Optional[pulumi.Input[str]]:
|
|
1033
|
+
"""
|
|
1034
|
+
Publication date in the Official Journal (RFC3339 format) for association information.
|
|
1035
|
+
"""
|
|
1036
|
+
return pulumi.get(self, "publication_jo")
|
|
1037
|
+
|
|
1038
|
+
@publication_jo.setter
|
|
1039
|
+
def publication_jo(self, value: Optional[pulumi.Input[str]]):
|
|
1040
|
+
pulumi.set(self, "publication_jo", value)
|
|
1041
|
+
|
|
1042
|
+
@property
|
|
1043
|
+
@pulumi.getter(name="publicationJoPage")
|
|
1044
|
+
def publication_jo_page(self) -> Optional[pulumi.Input[int]]:
|
|
1045
|
+
"""
|
|
1046
|
+
Page number of the publication in the Official Journal for association information.
|
|
1047
|
+
"""
|
|
1048
|
+
return pulumi.get(self, "publication_jo_page")
|
|
1049
|
+
|
|
1050
|
+
@publication_jo_page.setter
|
|
1051
|
+
def publication_jo_page(self, value: Optional[pulumi.Input[int]]):
|
|
1052
|
+
pulumi.set(self, "publication_jo_page", value)
|
|
1053
|
+
|
|
1054
|
+
|
|
1055
|
+
if not MYPY:
|
|
1056
|
+
class RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgsDict(TypedDict):
|
|
1057
|
+
code_auth_afnic: NotRequired[pulumi.Input[str]]
|
|
1058
|
+
"""
|
|
1059
|
+
AFNIC authorization code for the contact (specific to French domains).
|
|
1060
|
+
"""
|
|
1061
|
+
elif False:
|
|
1062
|
+
RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
1063
|
+
|
|
1064
|
+
@pulumi.input_type
|
|
1065
|
+
class RegistrationAdministrativeContactExtensionFrCodeAuthAfnicInfoArgs:
|
|
1066
|
+
def __init__(__self__, *,
|
|
1067
|
+
code_auth_afnic: Optional[pulumi.Input[str]] = None):
|
|
1068
|
+
"""
|
|
1069
|
+
:param pulumi.Input[str] code_auth_afnic: AFNIC authorization code for the contact (specific to French domains).
|
|
1070
|
+
"""
|
|
1071
|
+
if code_auth_afnic is not None:
|
|
1072
|
+
pulumi.set(__self__, "code_auth_afnic", code_auth_afnic)
|
|
1073
|
+
|
|
1074
|
+
@property
|
|
1075
|
+
@pulumi.getter(name="codeAuthAfnic")
|
|
1076
|
+
def code_auth_afnic(self) -> Optional[pulumi.Input[str]]:
|
|
1077
|
+
"""
|
|
1078
|
+
AFNIC authorization code for the contact (specific to French domains).
|
|
1079
|
+
"""
|
|
1080
|
+
return pulumi.get(self, "code_auth_afnic")
|
|
1081
|
+
|
|
1082
|
+
@code_auth_afnic.setter
|
|
1083
|
+
def code_auth_afnic(self, value: Optional[pulumi.Input[str]]):
|
|
1084
|
+
pulumi.set(self, "code_auth_afnic", value)
|
|
1085
|
+
|
|
1086
|
+
|
|
1087
|
+
if not MYPY:
|
|
1088
|
+
class RegistrationAdministrativeContactExtensionFrDunsInfoArgsDict(TypedDict):
|
|
1089
|
+
duns_id: NotRequired[pulumi.Input[str]]
|
|
1090
|
+
"""
|
|
1091
|
+
DUNS ID associated with the domain owner (for French domains).
|
|
1092
|
+
"""
|
|
1093
|
+
local_id: NotRequired[pulumi.Input[str]]
|
|
1094
|
+
"""
|
|
1095
|
+
Local identifier of the domain owner (for French domains).
|
|
1096
|
+
"""
|
|
1097
|
+
elif False:
|
|
1098
|
+
RegistrationAdministrativeContactExtensionFrDunsInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
1099
|
+
|
|
1100
|
+
@pulumi.input_type
|
|
1101
|
+
class RegistrationAdministrativeContactExtensionFrDunsInfoArgs:
|
|
1102
|
+
def __init__(__self__, *,
|
|
1103
|
+
duns_id: Optional[pulumi.Input[str]] = None,
|
|
1104
|
+
local_id: Optional[pulumi.Input[str]] = None):
|
|
1105
|
+
"""
|
|
1106
|
+
:param pulumi.Input[str] duns_id: DUNS ID associated with the domain owner (for French domains).
|
|
1107
|
+
:param pulumi.Input[str] local_id: Local identifier of the domain owner (for French domains).
|
|
1108
|
+
"""
|
|
1109
|
+
if duns_id is not None:
|
|
1110
|
+
pulumi.set(__self__, "duns_id", duns_id)
|
|
1111
|
+
if local_id is not None:
|
|
1112
|
+
pulumi.set(__self__, "local_id", local_id)
|
|
1113
|
+
|
|
1114
|
+
@property
|
|
1115
|
+
@pulumi.getter(name="dunsId")
|
|
1116
|
+
def duns_id(self) -> Optional[pulumi.Input[str]]:
|
|
1117
|
+
"""
|
|
1118
|
+
DUNS ID associated with the domain owner (for French domains).
|
|
1119
|
+
"""
|
|
1120
|
+
return pulumi.get(self, "duns_id")
|
|
1121
|
+
|
|
1122
|
+
@duns_id.setter
|
|
1123
|
+
def duns_id(self, value: Optional[pulumi.Input[str]]):
|
|
1124
|
+
pulumi.set(self, "duns_id", value)
|
|
1125
|
+
|
|
1126
|
+
@property
|
|
1127
|
+
@pulumi.getter(name="localId")
|
|
1128
|
+
def local_id(self) -> Optional[pulumi.Input[str]]:
|
|
1129
|
+
"""
|
|
1130
|
+
Local identifier of the domain owner (for French domains).
|
|
1131
|
+
"""
|
|
1132
|
+
return pulumi.get(self, "local_id")
|
|
1133
|
+
|
|
1134
|
+
@local_id.setter
|
|
1135
|
+
def local_id(self, value: Optional[pulumi.Input[str]]):
|
|
1136
|
+
pulumi.set(self, "local_id", value)
|
|
1137
|
+
|
|
1138
|
+
|
|
1139
|
+
if not MYPY:
|
|
1140
|
+
class RegistrationAdministrativeContactExtensionFrIndividualInfoArgsDict(TypedDict):
|
|
1141
|
+
whois_opt_in: NotRequired[pulumi.Input[bool]]
|
|
1142
|
+
"""
|
|
1143
|
+
Whether the individual contact has opted into WHOIS publishing.
|
|
1144
|
+
"""
|
|
1145
|
+
elif False:
|
|
1146
|
+
RegistrationAdministrativeContactExtensionFrIndividualInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
1147
|
+
|
|
1148
|
+
@pulumi.input_type
|
|
1149
|
+
class RegistrationAdministrativeContactExtensionFrIndividualInfoArgs:
|
|
1150
|
+
def __init__(__self__, *,
|
|
1151
|
+
whois_opt_in: Optional[pulumi.Input[bool]] = None):
|
|
1152
|
+
"""
|
|
1153
|
+
:param pulumi.Input[bool] whois_opt_in: Whether the individual contact has opted into WHOIS publishing.
|
|
1154
|
+
"""
|
|
1155
|
+
if whois_opt_in is not None:
|
|
1156
|
+
pulumi.set(__self__, "whois_opt_in", whois_opt_in)
|
|
1157
|
+
|
|
1158
|
+
@property
|
|
1159
|
+
@pulumi.getter(name="whoisOptIn")
|
|
1160
|
+
def whois_opt_in(self) -> Optional[pulumi.Input[bool]]:
|
|
1161
|
+
"""
|
|
1162
|
+
Whether the individual contact has opted into WHOIS publishing.
|
|
1163
|
+
"""
|
|
1164
|
+
return pulumi.get(self, "whois_opt_in")
|
|
1165
|
+
|
|
1166
|
+
@whois_opt_in.setter
|
|
1167
|
+
def whois_opt_in(self, value: Optional[pulumi.Input[bool]]):
|
|
1168
|
+
pulumi.set(self, "whois_opt_in", value)
|
|
1169
|
+
|
|
1170
|
+
|
|
1171
|
+
if not MYPY:
|
|
1172
|
+
class RegistrationAdministrativeContactExtensionFrTrademarkInfoArgsDict(TypedDict):
|
|
1173
|
+
trademark_inpi: NotRequired[pulumi.Input[str]]
|
|
1174
|
+
"""
|
|
1175
|
+
Trademark information from INPI (French extension).
|
|
1176
|
+
"""
|
|
1177
|
+
elif False:
|
|
1178
|
+
RegistrationAdministrativeContactExtensionFrTrademarkInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
1179
|
+
|
|
1180
|
+
@pulumi.input_type
|
|
1181
|
+
class RegistrationAdministrativeContactExtensionFrTrademarkInfoArgs:
|
|
1182
|
+
def __init__(__self__, *,
|
|
1183
|
+
trademark_inpi: Optional[pulumi.Input[str]] = None):
|
|
1184
|
+
"""
|
|
1185
|
+
:param pulumi.Input[str] trademark_inpi: Trademark information from INPI (French extension).
|
|
1186
|
+
"""
|
|
1187
|
+
if trademark_inpi is not None:
|
|
1188
|
+
pulumi.set(__self__, "trademark_inpi", trademark_inpi)
|
|
1189
|
+
|
|
1190
|
+
@property
|
|
1191
|
+
@pulumi.getter(name="trademarkInpi")
|
|
1192
|
+
def trademark_inpi(self) -> Optional[pulumi.Input[str]]:
|
|
1193
|
+
"""
|
|
1194
|
+
Trademark information from INPI (French extension).
|
|
1195
|
+
"""
|
|
1196
|
+
return pulumi.get(self, "trademark_inpi")
|
|
1197
|
+
|
|
1198
|
+
@trademark_inpi.setter
|
|
1199
|
+
def trademark_inpi(self, value: Optional[pulumi.Input[str]]):
|
|
1200
|
+
pulumi.set(self, "trademark_inpi", value)
|
|
1201
|
+
|
|
1202
|
+
|
|
1203
|
+
if not MYPY:
|
|
1204
|
+
class RegistrationDsRecordArgsDict(TypedDict):
|
|
1205
|
+
algorithm: NotRequired[pulumi.Input[str]]
|
|
1206
|
+
"""
|
|
1207
|
+
The algorithm used for dnssec (e.g., rsasha256, ecdsap256sha256).
|
|
1208
|
+
"""
|
|
1209
|
+
digests: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestArgsDict']]]]
|
|
1210
|
+
"""
|
|
1211
|
+
Details about the digest.
|
|
1212
|
+
"""
|
|
1213
|
+
key_id: NotRequired[pulumi.Input[int]]
|
|
1214
|
+
"""
|
|
1215
|
+
The identifier for the dnssec key.
|
|
1216
|
+
"""
|
|
1217
|
+
public_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordPublicKeyArgsDict']]]]
|
|
1218
|
+
"""
|
|
1219
|
+
Public key associated with the dnssec record.
|
|
1220
|
+
"""
|
|
1221
|
+
elif False:
|
|
1222
|
+
RegistrationDsRecordArgsDict: TypeAlias = Mapping[str, Any]
|
|
1223
|
+
|
|
1224
|
+
@pulumi.input_type
|
|
1225
|
+
class RegistrationDsRecordArgs:
|
|
1226
|
+
def __init__(__self__, *,
|
|
1227
|
+
algorithm: Optional[pulumi.Input[str]] = None,
|
|
1228
|
+
digests: Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestArgs']]]] = None,
|
|
1229
|
+
key_id: Optional[pulumi.Input[int]] = None,
|
|
1230
|
+
public_keys: Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordPublicKeyArgs']]]] = None):
|
|
1231
|
+
"""
|
|
1232
|
+
:param pulumi.Input[str] algorithm: The algorithm used for dnssec (e.g., rsasha256, ecdsap256sha256).
|
|
1233
|
+
:param pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestArgs']]] digests: Details about the digest.
|
|
1234
|
+
:param pulumi.Input[int] key_id: The identifier for the dnssec key.
|
|
1235
|
+
:param pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordPublicKeyArgs']]] public_keys: Public key associated with the dnssec record.
|
|
1236
|
+
"""
|
|
1237
|
+
if algorithm is not None:
|
|
1238
|
+
pulumi.set(__self__, "algorithm", algorithm)
|
|
1239
|
+
if digests is not None:
|
|
1240
|
+
pulumi.set(__self__, "digests", digests)
|
|
1241
|
+
if key_id is not None:
|
|
1242
|
+
pulumi.set(__self__, "key_id", key_id)
|
|
1243
|
+
if public_keys is not None:
|
|
1244
|
+
pulumi.set(__self__, "public_keys", public_keys)
|
|
1245
|
+
|
|
1246
|
+
@property
|
|
1247
|
+
@pulumi.getter
|
|
1248
|
+
def algorithm(self) -> Optional[pulumi.Input[str]]:
|
|
1249
|
+
"""
|
|
1250
|
+
The algorithm used for dnssec (e.g., rsasha256, ecdsap256sha256).
|
|
1251
|
+
"""
|
|
1252
|
+
return pulumi.get(self, "algorithm")
|
|
1253
|
+
|
|
1254
|
+
@algorithm.setter
|
|
1255
|
+
def algorithm(self, value: Optional[pulumi.Input[str]]):
|
|
1256
|
+
pulumi.set(self, "algorithm", value)
|
|
1257
|
+
|
|
1258
|
+
@property
|
|
1259
|
+
@pulumi.getter
|
|
1260
|
+
def digests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestArgs']]]]:
|
|
1261
|
+
"""
|
|
1262
|
+
Details about the digest.
|
|
1263
|
+
"""
|
|
1264
|
+
return pulumi.get(self, "digests")
|
|
1265
|
+
|
|
1266
|
+
@digests.setter
|
|
1267
|
+
def digests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestArgs']]]]):
|
|
1268
|
+
pulumi.set(self, "digests", value)
|
|
1269
|
+
|
|
1270
|
+
@property
|
|
1271
|
+
@pulumi.getter(name="keyId")
|
|
1272
|
+
def key_id(self) -> Optional[pulumi.Input[int]]:
|
|
1273
|
+
"""
|
|
1274
|
+
The identifier for the dnssec key.
|
|
1275
|
+
"""
|
|
1276
|
+
return pulumi.get(self, "key_id")
|
|
1277
|
+
|
|
1278
|
+
@key_id.setter
|
|
1279
|
+
def key_id(self, value: Optional[pulumi.Input[int]]):
|
|
1280
|
+
pulumi.set(self, "key_id", value)
|
|
1281
|
+
|
|
1282
|
+
@property
|
|
1283
|
+
@pulumi.getter(name="publicKeys")
|
|
1284
|
+
def public_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordPublicKeyArgs']]]]:
|
|
1285
|
+
"""
|
|
1286
|
+
Public key associated with the dnssec record.
|
|
1287
|
+
"""
|
|
1288
|
+
return pulumi.get(self, "public_keys")
|
|
1289
|
+
|
|
1290
|
+
@public_keys.setter
|
|
1291
|
+
def public_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordPublicKeyArgs']]]]):
|
|
1292
|
+
pulumi.set(self, "public_keys", value)
|
|
1293
|
+
|
|
1294
|
+
|
|
1295
|
+
if not MYPY:
|
|
1296
|
+
class RegistrationDsRecordDigestArgsDict(TypedDict):
|
|
1297
|
+
digest: NotRequired[pulumi.Input[str]]
|
|
1298
|
+
"""
|
|
1299
|
+
The digest value.
|
|
1300
|
+
"""
|
|
1301
|
+
public_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestPublicKeyArgsDict']]]]
|
|
1302
|
+
"""
|
|
1303
|
+
The public key associated with the digest.
|
|
1304
|
+
"""
|
|
1305
|
+
type: NotRequired[pulumi.Input[str]]
|
|
1306
|
+
"""
|
|
1307
|
+
The digest type for the DS record (e.g., sha_1, sha_256, gost_r_34_11_94, sha_384).
|
|
1308
|
+
"""
|
|
1309
|
+
elif False:
|
|
1310
|
+
RegistrationDsRecordDigestArgsDict: TypeAlias = Mapping[str, Any]
|
|
1311
|
+
|
|
1312
|
+
@pulumi.input_type
|
|
1313
|
+
class RegistrationDsRecordDigestArgs:
|
|
1314
|
+
def __init__(__self__, *,
|
|
1315
|
+
digest: Optional[pulumi.Input[str]] = None,
|
|
1316
|
+
public_keys: Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestPublicKeyArgs']]]] = None,
|
|
1317
|
+
type: Optional[pulumi.Input[str]] = None):
|
|
1318
|
+
"""
|
|
1319
|
+
:param pulumi.Input[str] digest: The digest value.
|
|
1320
|
+
:param pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestPublicKeyArgs']]] public_keys: The public key associated with the digest.
|
|
1321
|
+
:param pulumi.Input[str] type: The digest type for the DS record (e.g., sha_1, sha_256, gost_r_34_11_94, sha_384).
|
|
1322
|
+
"""
|
|
1323
|
+
if digest is not None:
|
|
1324
|
+
pulumi.set(__self__, "digest", digest)
|
|
1325
|
+
if public_keys is not None:
|
|
1326
|
+
pulumi.set(__self__, "public_keys", public_keys)
|
|
1327
|
+
if type is not None:
|
|
1328
|
+
pulumi.set(__self__, "type", type)
|
|
1329
|
+
|
|
1330
|
+
@property
|
|
1331
|
+
@pulumi.getter
|
|
1332
|
+
def digest(self) -> Optional[pulumi.Input[str]]:
|
|
1333
|
+
"""
|
|
1334
|
+
The digest value.
|
|
1335
|
+
"""
|
|
1336
|
+
return pulumi.get(self, "digest")
|
|
1337
|
+
|
|
1338
|
+
@digest.setter
|
|
1339
|
+
def digest(self, value: Optional[pulumi.Input[str]]):
|
|
1340
|
+
pulumi.set(self, "digest", value)
|
|
1341
|
+
|
|
1342
|
+
@property
|
|
1343
|
+
@pulumi.getter(name="publicKeys")
|
|
1344
|
+
def public_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestPublicKeyArgs']]]]:
|
|
1345
|
+
"""
|
|
1346
|
+
The public key associated with the digest.
|
|
1347
|
+
"""
|
|
1348
|
+
return pulumi.get(self, "public_keys")
|
|
1349
|
+
|
|
1350
|
+
@public_keys.setter
|
|
1351
|
+
def public_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegistrationDsRecordDigestPublicKeyArgs']]]]):
|
|
1352
|
+
pulumi.set(self, "public_keys", value)
|
|
1353
|
+
|
|
1354
|
+
@property
|
|
1355
|
+
@pulumi.getter
|
|
1356
|
+
def type(self) -> Optional[pulumi.Input[str]]:
|
|
1357
|
+
"""
|
|
1358
|
+
The digest type for the DS record (e.g., sha_1, sha_256, gost_r_34_11_94, sha_384).
|
|
1359
|
+
"""
|
|
1360
|
+
return pulumi.get(self, "type")
|
|
1361
|
+
|
|
1362
|
+
@type.setter
|
|
1363
|
+
def type(self, value: Optional[pulumi.Input[str]]):
|
|
1364
|
+
pulumi.set(self, "type", value)
|
|
1365
|
+
|
|
1366
|
+
|
|
1367
|
+
if not MYPY:
|
|
1368
|
+
class RegistrationDsRecordDigestPublicKeyArgsDict(TypedDict):
|
|
1369
|
+
key: pulumi.Input[str]
|
|
1370
|
+
"""
|
|
1371
|
+
The public key value.
|
|
1372
|
+
"""
|
|
1373
|
+
elif False:
|
|
1374
|
+
RegistrationDsRecordDigestPublicKeyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1375
|
+
|
|
1376
|
+
@pulumi.input_type
|
|
1377
|
+
class RegistrationDsRecordDigestPublicKeyArgs:
|
|
1378
|
+
def __init__(__self__, *,
|
|
1379
|
+
key: pulumi.Input[str]):
|
|
1380
|
+
"""
|
|
1381
|
+
:param pulumi.Input[str] key: The public key value.
|
|
1382
|
+
"""
|
|
1383
|
+
pulumi.set(__self__, "key", key)
|
|
1384
|
+
|
|
1385
|
+
@property
|
|
1386
|
+
@pulumi.getter
|
|
1387
|
+
def key(self) -> pulumi.Input[str]:
|
|
1388
|
+
"""
|
|
1389
|
+
The public key value.
|
|
1390
|
+
"""
|
|
1391
|
+
return pulumi.get(self, "key")
|
|
1392
|
+
|
|
1393
|
+
@key.setter
|
|
1394
|
+
def key(self, value: pulumi.Input[str]):
|
|
1395
|
+
pulumi.set(self, "key", value)
|
|
1396
|
+
|
|
1397
|
+
|
|
1398
|
+
if not MYPY:
|
|
1399
|
+
class RegistrationDsRecordPublicKeyArgsDict(TypedDict):
|
|
1400
|
+
key: pulumi.Input[str]
|
|
1401
|
+
"""
|
|
1402
|
+
The public key value.
|
|
1403
|
+
"""
|
|
1404
|
+
elif False:
|
|
1405
|
+
RegistrationDsRecordPublicKeyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1406
|
+
|
|
1407
|
+
@pulumi.input_type
|
|
1408
|
+
class RegistrationDsRecordPublicKeyArgs:
|
|
1409
|
+
def __init__(__self__, *,
|
|
1410
|
+
key: pulumi.Input[str]):
|
|
1411
|
+
"""
|
|
1412
|
+
:param pulumi.Input[str] key: The public key value.
|
|
1413
|
+
"""
|
|
1414
|
+
pulumi.set(__self__, "key", key)
|
|
1415
|
+
|
|
1416
|
+
@property
|
|
1417
|
+
@pulumi.getter
|
|
1418
|
+
def key(self) -> pulumi.Input[str]:
|
|
1419
|
+
"""
|
|
1420
|
+
The public key value.
|
|
1421
|
+
"""
|
|
1422
|
+
return pulumi.get(self, "key")
|
|
1423
|
+
|
|
1424
|
+
@key.setter
|
|
1425
|
+
def key(self, value: pulumi.Input[str]):
|
|
1426
|
+
pulumi.set(self, "key", value)
|
|
1427
|
+
|
|
1428
|
+
|
|
1429
|
+
if not MYPY:
|
|
1430
|
+
class RegistrationOwnerContactArgsDict(TypedDict):
|
|
1431
|
+
address_line1: pulumi.Input[str]
|
|
1432
|
+
"""
|
|
1433
|
+
Primary address line for the contact.
|
|
1434
|
+
"""
|
|
1435
|
+
city: pulumi.Input[str]
|
|
1436
|
+
"""
|
|
1437
|
+
City of the contact's address.
|
|
1438
|
+
"""
|
|
1439
|
+
company_identification_code: pulumi.Input[str]
|
|
1440
|
+
"""
|
|
1441
|
+
Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
1442
|
+
"""
|
|
1443
|
+
country: pulumi.Input[str]
|
|
1444
|
+
"""
|
|
1445
|
+
Country code of the contact's address (ISO format).
|
|
1446
|
+
"""
|
|
1447
|
+
email: pulumi.Input[str]
|
|
1448
|
+
"""
|
|
1449
|
+
Primary email address of the contact.
|
|
1450
|
+
"""
|
|
1451
|
+
firstname: pulumi.Input[str]
|
|
1452
|
+
"""
|
|
1453
|
+
First name of the contact.
|
|
1454
|
+
"""
|
|
1455
|
+
lastname: pulumi.Input[str]
|
|
1456
|
+
"""
|
|
1457
|
+
Last name of the contact.
|
|
1458
|
+
"""
|
|
1459
|
+
legal_form: pulumi.Input[str]
|
|
1460
|
+
"""
|
|
1461
|
+
Legal form of the contact (e.g., 'individual' or 'organization').
|
|
1462
|
+
"""
|
|
1463
|
+
phone_number: pulumi.Input[str]
|
|
1464
|
+
"""
|
|
1465
|
+
Primary phone number of the contact.
|
|
1466
|
+
"""
|
|
1467
|
+
vat_identification_code: pulumi.Input[str]
|
|
1468
|
+
"""
|
|
1469
|
+
VAT identification code of the contact, if applicable.
|
|
1470
|
+
"""
|
|
1471
|
+
zip: pulumi.Input[str]
|
|
1472
|
+
"""
|
|
1473
|
+
Postal code of the contact's address.
|
|
1474
|
+
"""
|
|
1475
|
+
address_line2: NotRequired[pulumi.Input[str]]
|
|
1476
|
+
"""
|
|
1477
|
+
Secondary address line for the contact (optional).
|
|
1478
|
+
"""
|
|
1479
|
+
company_name: NotRequired[pulumi.Input[str]]
|
|
1480
|
+
"""
|
|
1481
|
+
Name of the company associated with the contact (if applicable).
|
|
1482
|
+
"""
|
|
1483
|
+
email_alt: NotRequired[pulumi.Input[str]]
|
|
1484
|
+
"""
|
|
1485
|
+
Alternative email address for the contact.
|
|
1486
|
+
"""
|
|
1487
|
+
extension_eu: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionEuArgsDict']]
|
|
1488
|
+
"""
|
|
1489
|
+
Details specific to European domain extensions.
|
|
1490
|
+
"""
|
|
1491
|
+
extension_fr: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionFrArgsDict']]
|
|
1492
|
+
"""
|
|
1493
|
+
Details specific to French domain extensions.
|
|
1494
|
+
"""
|
|
1495
|
+
extension_nls: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1496
|
+
"""
|
|
1497
|
+
Extension details specific to Dutch domain registrations.
|
|
1498
|
+
"""
|
|
1499
|
+
fax_number: NotRequired[pulumi.Input[str]]
|
|
1500
|
+
"""
|
|
1501
|
+
Fax number for the contact (if available).
|
|
1502
|
+
"""
|
|
1503
|
+
lang: NotRequired[pulumi.Input[str]]
|
|
1504
|
+
"""
|
|
1505
|
+
Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
1506
|
+
"""
|
|
1507
|
+
resale: NotRequired[pulumi.Input[bool]]
|
|
1508
|
+
"""
|
|
1509
|
+
Indicates if the contact is used for resale purposes.
|
|
1510
|
+
"""
|
|
1511
|
+
state: NotRequired[pulumi.Input[str]]
|
|
1512
|
+
"""
|
|
1513
|
+
State or region of the contact.
|
|
1514
|
+
"""
|
|
1515
|
+
whois_opt_in: NotRequired[pulumi.Input[bool]]
|
|
1516
|
+
"""
|
|
1517
|
+
Indicates whether the contact has opted into WHOIS publishing.
|
|
1518
|
+
"""
|
|
1519
|
+
elif False:
|
|
1520
|
+
RegistrationOwnerContactArgsDict: TypeAlias = Mapping[str, Any]
|
|
1521
|
+
|
|
1522
|
+
@pulumi.input_type
|
|
1523
|
+
class RegistrationOwnerContactArgs:
|
|
1524
|
+
def __init__(__self__, *,
|
|
1525
|
+
address_line1: pulumi.Input[str],
|
|
1526
|
+
city: pulumi.Input[str],
|
|
1527
|
+
company_identification_code: pulumi.Input[str],
|
|
1528
|
+
country: pulumi.Input[str],
|
|
1529
|
+
email: pulumi.Input[str],
|
|
1530
|
+
firstname: pulumi.Input[str],
|
|
1531
|
+
lastname: pulumi.Input[str],
|
|
1532
|
+
legal_form: pulumi.Input[str],
|
|
1533
|
+
phone_number: pulumi.Input[str],
|
|
1534
|
+
vat_identification_code: pulumi.Input[str],
|
|
1535
|
+
zip: pulumi.Input[str],
|
|
1536
|
+
address_line2: Optional[pulumi.Input[str]] = None,
|
|
1537
|
+
company_name: Optional[pulumi.Input[str]] = None,
|
|
1538
|
+
email_alt: Optional[pulumi.Input[str]] = None,
|
|
1539
|
+
extension_eu: Optional[pulumi.Input['RegistrationOwnerContactExtensionEuArgs']] = None,
|
|
1540
|
+
extension_fr: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrArgs']] = None,
|
|
1541
|
+
extension_nls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1542
|
+
fax_number: Optional[pulumi.Input[str]] = None,
|
|
1543
|
+
lang: Optional[pulumi.Input[str]] = None,
|
|
1544
|
+
resale: Optional[pulumi.Input[bool]] = None,
|
|
1545
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
1546
|
+
whois_opt_in: Optional[pulumi.Input[bool]] = None):
|
|
1547
|
+
"""
|
|
1548
|
+
:param pulumi.Input[str] address_line1: Primary address line for the contact.
|
|
1549
|
+
:param pulumi.Input[str] city: City of the contact's address.
|
|
1550
|
+
:param pulumi.Input[str] company_identification_code: Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
1551
|
+
:param pulumi.Input[str] country: Country code of the contact's address (ISO format).
|
|
1552
|
+
:param pulumi.Input[str] email: Primary email address of the contact.
|
|
1553
|
+
:param pulumi.Input[str] firstname: First name of the contact.
|
|
1554
|
+
:param pulumi.Input[str] lastname: Last name of the contact.
|
|
1555
|
+
:param pulumi.Input[str] legal_form: Legal form of the contact (e.g., 'individual' or 'organization').
|
|
1556
|
+
:param pulumi.Input[str] phone_number: Primary phone number of the contact.
|
|
1557
|
+
:param pulumi.Input[str] vat_identification_code: VAT identification code of the contact, if applicable.
|
|
1558
|
+
:param pulumi.Input[str] zip: Postal code of the contact's address.
|
|
1559
|
+
:param pulumi.Input[str] address_line2: Secondary address line for the contact (optional).
|
|
1560
|
+
:param pulumi.Input[str] company_name: Name of the company associated with the contact (if applicable).
|
|
1561
|
+
:param pulumi.Input[str] email_alt: Alternative email address for the contact.
|
|
1562
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionEuArgs'] extension_eu: Details specific to European domain extensions.
|
|
1563
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionFrArgs'] extension_fr: Details specific to French domain extensions.
|
|
1564
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] extension_nls: Extension details specific to Dutch domain registrations.
|
|
1565
|
+
:param pulumi.Input[str] fax_number: Fax number for the contact (if available).
|
|
1566
|
+
:param pulumi.Input[str] lang: Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
1567
|
+
:param pulumi.Input[bool] resale: Indicates if the contact is used for resale purposes.
|
|
1568
|
+
:param pulumi.Input[str] state: State or region of the contact.
|
|
1569
|
+
:param pulumi.Input[bool] whois_opt_in: Indicates whether the contact has opted into WHOIS publishing.
|
|
1570
|
+
"""
|
|
1571
|
+
pulumi.set(__self__, "address_line1", address_line1)
|
|
1572
|
+
pulumi.set(__self__, "city", city)
|
|
1573
|
+
pulumi.set(__self__, "company_identification_code", company_identification_code)
|
|
1574
|
+
pulumi.set(__self__, "country", country)
|
|
1575
|
+
pulumi.set(__self__, "email", email)
|
|
1576
|
+
pulumi.set(__self__, "firstname", firstname)
|
|
1577
|
+
pulumi.set(__self__, "lastname", lastname)
|
|
1578
|
+
pulumi.set(__self__, "legal_form", legal_form)
|
|
1579
|
+
pulumi.set(__self__, "phone_number", phone_number)
|
|
1580
|
+
pulumi.set(__self__, "vat_identification_code", vat_identification_code)
|
|
1581
|
+
pulumi.set(__self__, "zip", zip)
|
|
1582
|
+
if address_line2 is not None:
|
|
1583
|
+
pulumi.set(__self__, "address_line2", address_line2)
|
|
1584
|
+
if company_name is not None:
|
|
1585
|
+
pulumi.set(__self__, "company_name", company_name)
|
|
1586
|
+
if email_alt is not None:
|
|
1587
|
+
pulumi.set(__self__, "email_alt", email_alt)
|
|
1588
|
+
if extension_eu is not None:
|
|
1589
|
+
pulumi.set(__self__, "extension_eu", extension_eu)
|
|
1590
|
+
if extension_fr is not None:
|
|
1591
|
+
pulumi.set(__self__, "extension_fr", extension_fr)
|
|
1592
|
+
if extension_nls is not None:
|
|
1593
|
+
pulumi.set(__self__, "extension_nls", extension_nls)
|
|
1594
|
+
if fax_number is not None:
|
|
1595
|
+
pulumi.set(__self__, "fax_number", fax_number)
|
|
1596
|
+
if lang is not None:
|
|
1597
|
+
pulumi.set(__self__, "lang", lang)
|
|
1598
|
+
if resale is not None:
|
|
1599
|
+
pulumi.set(__self__, "resale", resale)
|
|
1600
|
+
if state is not None:
|
|
1601
|
+
pulumi.set(__self__, "state", state)
|
|
1602
|
+
if whois_opt_in is not None:
|
|
1603
|
+
pulumi.set(__self__, "whois_opt_in", whois_opt_in)
|
|
1604
|
+
|
|
1605
|
+
@property
|
|
1606
|
+
@pulumi.getter(name="addressLine1")
|
|
1607
|
+
def address_line1(self) -> pulumi.Input[str]:
|
|
1608
|
+
"""
|
|
1609
|
+
Primary address line for the contact.
|
|
1610
|
+
"""
|
|
1611
|
+
return pulumi.get(self, "address_line1")
|
|
1612
|
+
|
|
1613
|
+
@address_line1.setter
|
|
1614
|
+
def address_line1(self, value: pulumi.Input[str]):
|
|
1615
|
+
pulumi.set(self, "address_line1", value)
|
|
1616
|
+
|
|
1617
|
+
@property
|
|
1618
|
+
@pulumi.getter
|
|
1619
|
+
def city(self) -> pulumi.Input[str]:
|
|
1620
|
+
"""
|
|
1621
|
+
City of the contact's address.
|
|
1622
|
+
"""
|
|
1623
|
+
return pulumi.get(self, "city")
|
|
1624
|
+
|
|
1625
|
+
@city.setter
|
|
1626
|
+
def city(self, value: pulumi.Input[str]):
|
|
1627
|
+
pulumi.set(self, "city", value)
|
|
1628
|
+
|
|
1629
|
+
@property
|
|
1630
|
+
@pulumi.getter(name="companyIdentificationCode")
|
|
1631
|
+
def company_identification_code(self) -> pulumi.Input[str]:
|
|
1632
|
+
"""
|
|
1633
|
+
Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
1634
|
+
"""
|
|
1635
|
+
return pulumi.get(self, "company_identification_code")
|
|
1636
|
+
|
|
1637
|
+
@company_identification_code.setter
|
|
1638
|
+
def company_identification_code(self, value: pulumi.Input[str]):
|
|
1639
|
+
pulumi.set(self, "company_identification_code", value)
|
|
1640
|
+
|
|
1641
|
+
@property
|
|
1642
|
+
@pulumi.getter
|
|
1643
|
+
def country(self) -> pulumi.Input[str]:
|
|
1644
|
+
"""
|
|
1645
|
+
Country code of the contact's address (ISO format).
|
|
1646
|
+
"""
|
|
1647
|
+
return pulumi.get(self, "country")
|
|
1648
|
+
|
|
1649
|
+
@country.setter
|
|
1650
|
+
def country(self, value: pulumi.Input[str]):
|
|
1651
|
+
pulumi.set(self, "country", value)
|
|
1652
|
+
|
|
1653
|
+
@property
|
|
1654
|
+
@pulumi.getter
|
|
1655
|
+
def email(self) -> pulumi.Input[str]:
|
|
1656
|
+
"""
|
|
1657
|
+
Primary email address of the contact.
|
|
1658
|
+
"""
|
|
1659
|
+
return pulumi.get(self, "email")
|
|
1660
|
+
|
|
1661
|
+
@email.setter
|
|
1662
|
+
def email(self, value: pulumi.Input[str]):
|
|
1663
|
+
pulumi.set(self, "email", value)
|
|
1664
|
+
|
|
1665
|
+
@property
|
|
1666
|
+
@pulumi.getter
|
|
1667
|
+
def firstname(self) -> pulumi.Input[str]:
|
|
1668
|
+
"""
|
|
1669
|
+
First name of the contact.
|
|
1670
|
+
"""
|
|
1671
|
+
return pulumi.get(self, "firstname")
|
|
1672
|
+
|
|
1673
|
+
@firstname.setter
|
|
1674
|
+
def firstname(self, value: pulumi.Input[str]):
|
|
1675
|
+
pulumi.set(self, "firstname", value)
|
|
1676
|
+
|
|
1677
|
+
@property
|
|
1678
|
+
@pulumi.getter
|
|
1679
|
+
def lastname(self) -> pulumi.Input[str]:
|
|
1680
|
+
"""
|
|
1681
|
+
Last name of the contact.
|
|
1682
|
+
"""
|
|
1683
|
+
return pulumi.get(self, "lastname")
|
|
1684
|
+
|
|
1685
|
+
@lastname.setter
|
|
1686
|
+
def lastname(self, value: pulumi.Input[str]):
|
|
1687
|
+
pulumi.set(self, "lastname", value)
|
|
1688
|
+
|
|
1689
|
+
@property
|
|
1690
|
+
@pulumi.getter(name="legalForm")
|
|
1691
|
+
def legal_form(self) -> pulumi.Input[str]:
|
|
1692
|
+
"""
|
|
1693
|
+
Legal form of the contact (e.g., 'individual' or 'organization').
|
|
1694
|
+
"""
|
|
1695
|
+
return pulumi.get(self, "legal_form")
|
|
1696
|
+
|
|
1697
|
+
@legal_form.setter
|
|
1698
|
+
def legal_form(self, value: pulumi.Input[str]):
|
|
1699
|
+
pulumi.set(self, "legal_form", value)
|
|
1700
|
+
|
|
1701
|
+
@property
|
|
1702
|
+
@pulumi.getter(name="phoneNumber")
|
|
1703
|
+
def phone_number(self) -> pulumi.Input[str]:
|
|
1704
|
+
"""
|
|
1705
|
+
Primary phone number of the contact.
|
|
1706
|
+
"""
|
|
1707
|
+
return pulumi.get(self, "phone_number")
|
|
1708
|
+
|
|
1709
|
+
@phone_number.setter
|
|
1710
|
+
def phone_number(self, value: pulumi.Input[str]):
|
|
1711
|
+
pulumi.set(self, "phone_number", value)
|
|
1712
|
+
|
|
1713
|
+
@property
|
|
1714
|
+
@pulumi.getter(name="vatIdentificationCode")
|
|
1715
|
+
def vat_identification_code(self) -> pulumi.Input[str]:
|
|
1716
|
+
"""
|
|
1717
|
+
VAT identification code of the contact, if applicable.
|
|
1718
|
+
"""
|
|
1719
|
+
return pulumi.get(self, "vat_identification_code")
|
|
1720
|
+
|
|
1721
|
+
@vat_identification_code.setter
|
|
1722
|
+
def vat_identification_code(self, value: pulumi.Input[str]):
|
|
1723
|
+
pulumi.set(self, "vat_identification_code", value)
|
|
1724
|
+
|
|
1725
|
+
@property
|
|
1726
|
+
@pulumi.getter
|
|
1727
|
+
def zip(self) -> pulumi.Input[str]:
|
|
1728
|
+
"""
|
|
1729
|
+
Postal code of the contact's address.
|
|
1730
|
+
"""
|
|
1731
|
+
return pulumi.get(self, "zip")
|
|
1732
|
+
|
|
1733
|
+
@zip.setter
|
|
1734
|
+
def zip(self, value: pulumi.Input[str]):
|
|
1735
|
+
pulumi.set(self, "zip", value)
|
|
1736
|
+
|
|
1737
|
+
@property
|
|
1738
|
+
@pulumi.getter(name="addressLine2")
|
|
1739
|
+
def address_line2(self) -> Optional[pulumi.Input[str]]:
|
|
1740
|
+
"""
|
|
1741
|
+
Secondary address line for the contact (optional).
|
|
1742
|
+
"""
|
|
1743
|
+
return pulumi.get(self, "address_line2")
|
|
1744
|
+
|
|
1745
|
+
@address_line2.setter
|
|
1746
|
+
def address_line2(self, value: Optional[pulumi.Input[str]]):
|
|
1747
|
+
pulumi.set(self, "address_line2", value)
|
|
1748
|
+
|
|
1749
|
+
@property
|
|
1750
|
+
@pulumi.getter(name="companyName")
|
|
1751
|
+
def company_name(self) -> Optional[pulumi.Input[str]]:
|
|
1752
|
+
"""
|
|
1753
|
+
Name of the company associated with the contact (if applicable).
|
|
1754
|
+
"""
|
|
1755
|
+
return pulumi.get(self, "company_name")
|
|
1756
|
+
|
|
1757
|
+
@company_name.setter
|
|
1758
|
+
def company_name(self, value: Optional[pulumi.Input[str]]):
|
|
1759
|
+
pulumi.set(self, "company_name", value)
|
|
1760
|
+
|
|
1761
|
+
@property
|
|
1762
|
+
@pulumi.getter(name="emailAlt")
|
|
1763
|
+
def email_alt(self) -> Optional[pulumi.Input[str]]:
|
|
1764
|
+
"""
|
|
1765
|
+
Alternative email address for the contact.
|
|
1766
|
+
"""
|
|
1767
|
+
return pulumi.get(self, "email_alt")
|
|
1768
|
+
|
|
1769
|
+
@email_alt.setter
|
|
1770
|
+
def email_alt(self, value: Optional[pulumi.Input[str]]):
|
|
1771
|
+
pulumi.set(self, "email_alt", value)
|
|
1772
|
+
|
|
1773
|
+
@property
|
|
1774
|
+
@pulumi.getter(name="extensionEu")
|
|
1775
|
+
def extension_eu(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionEuArgs']]:
|
|
1776
|
+
"""
|
|
1777
|
+
Details specific to European domain extensions.
|
|
1778
|
+
"""
|
|
1779
|
+
return pulumi.get(self, "extension_eu")
|
|
1780
|
+
|
|
1781
|
+
@extension_eu.setter
|
|
1782
|
+
def extension_eu(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionEuArgs']]):
|
|
1783
|
+
pulumi.set(self, "extension_eu", value)
|
|
1784
|
+
|
|
1785
|
+
@property
|
|
1786
|
+
@pulumi.getter(name="extensionFr")
|
|
1787
|
+
def extension_fr(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionFrArgs']]:
|
|
1788
|
+
"""
|
|
1789
|
+
Details specific to French domain extensions.
|
|
1790
|
+
"""
|
|
1791
|
+
return pulumi.get(self, "extension_fr")
|
|
1792
|
+
|
|
1793
|
+
@extension_fr.setter
|
|
1794
|
+
def extension_fr(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrArgs']]):
|
|
1795
|
+
pulumi.set(self, "extension_fr", value)
|
|
1796
|
+
|
|
1797
|
+
@property
|
|
1798
|
+
@pulumi.getter(name="extensionNls")
|
|
1799
|
+
def extension_nls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1800
|
+
"""
|
|
1801
|
+
Extension details specific to Dutch domain registrations.
|
|
1802
|
+
"""
|
|
1803
|
+
return pulumi.get(self, "extension_nls")
|
|
1804
|
+
|
|
1805
|
+
@extension_nls.setter
|
|
1806
|
+
def extension_nls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1807
|
+
pulumi.set(self, "extension_nls", value)
|
|
1808
|
+
|
|
1809
|
+
@property
|
|
1810
|
+
@pulumi.getter(name="faxNumber")
|
|
1811
|
+
def fax_number(self) -> Optional[pulumi.Input[str]]:
|
|
1812
|
+
"""
|
|
1813
|
+
Fax number for the contact (if available).
|
|
1814
|
+
"""
|
|
1815
|
+
return pulumi.get(self, "fax_number")
|
|
1816
|
+
|
|
1817
|
+
@fax_number.setter
|
|
1818
|
+
def fax_number(self, value: Optional[pulumi.Input[str]]):
|
|
1819
|
+
pulumi.set(self, "fax_number", value)
|
|
1820
|
+
|
|
1821
|
+
@property
|
|
1822
|
+
@pulumi.getter
|
|
1823
|
+
def lang(self) -> Optional[pulumi.Input[str]]:
|
|
1824
|
+
"""
|
|
1825
|
+
Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
1826
|
+
"""
|
|
1827
|
+
return pulumi.get(self, "lang")
|
|
1828
|
+
|
|
1829
|
+
@lang.setter
|
|
1830
|
+
def lang(self, value: Optional[pulumi.Input[str]]):
|
|
1831
|
+
pulumi.set(self, "lang", value)
|
|
1832
|
+
|
|
1833
|
+
@property
|
|
1834
|
+
@pulumi.getter
|
|
1835
|
+
def resale(self) -> Optional[pulumi.Input[bool]]:
|
|
1836
|
+
"""
|
|
1837
|
+
Indicates if the contact is used for resale purposes.
|
|
1838
|
+
"""
|
|
1839
|
+
return pulumi.get(self, "resale")
|
|
1840
|
+
|
|
1841
|
+
@resale.setter
|
|
1842
|
+
def resale(self, value: Optional[pulumi.Input[bool]]):
|
|
1843
|
+
pulumi.set(self, "resale", value)
|
|
1844
|
+
|
|
1845
|
+
@property
|
|
1846
|
+
@pulumi.getter
|
|
1847
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
1848
|
+
"""
|
|
1849
|
+
State or region of the contact.
|
|
1850
|
+
"""
|
|
1851
|
+
return pulumi.get(self, "state")
|
|
1852
|
+
|
|
1853
|
+
@state.setter
|
|
1854
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
1855
|
+
pulumi.set(self, "state", value)
|
|
1856
|
+
|
|
1857
|
+
@property
|
|
1858
|
+
@pulumi.getter(name="whoisOptIn")
|
|
1859
|
+
def whois_opt_in(self) -> Optional[pulumi.Input[bool]]:
|
|
1860
|
+
"""
|
|
1861
|
+
Indicates whether the contact has opted into WHOIS publishing.
|
|
1862
|
+
"""
|
|
1863
|
+
return pulumi.get(self, "whois_opt_in")
|
|
1864
|
+
|
|
1865
|
+
@whois_opt_in.setter
|
|
1866
|
+
def whois_opt_in(self, value: Optional[pulumi.Input[bool]]):
|
|
1867
|
+
pulumi.set(self, "whois_opt_in", value)
|
|
1868
|
+
|
|
1869
|
+
|
|
1870
|
+
if not MYPY:
|
|
1871
|
+
class RegistrationOwnerContactExtensionEuArgsDict(TypedDict):
|
|
1872
|
+
european_citizenship: NotRequired[pulumi.Input[str]]
|
|
1873
|
+
"""
|
|
1874
|
+
Indicates the European citizenship of the contact.
|
|
1875
|
+
"""
|
|
1876
|
+
elif False:
|
|
1877
|
+
RegistrationOwnerContactExtensionEuArgsDict: TypeAlias = Mapping[str, Any]
|
|
1878
|
+
|
|
1879
|
+
@pulumi.input_type
|
|
1880
|
+
class RegistrationOwnerContactExtensionEuArgs:
|
|
1881
|
+
def __init__(__self__, *,
|
|
1882
|
+
european_citizenship: Optional[pulumi.Input[str]] = None):
|
|
1883
|
+
"""
|
|
1884
|
+
:param pulumi.Input[str] european_citizenship: Indicates the European citizenship of the contact.
|
|
1885
|
+
"""
|
|
1886
|
+
if european_citizenship is not None:
|
|
1887
|
+
pulumi.set(__self__, "european_citizenship", european_citizenship)
|
|
1888
|
+
|
|
1889
|
+
@property
|
|
1890
|
+
@pulumi.getter(name="europeanCitizenship")
|
|
1891
|
+
def european_citizenship(self) -> Optional[pulumi.Input[str]]:
|
|
1892
|
+
"""
|
|
1893
|
+
Indicates the European citizenship of the contact.
|
|
1894
|
+
"""
|
|
1895
|
+
return pulumi.get(self, "european_citizenship")
|
|
1896
|
+
|
|
1897
|
+
@european_citizenship.setter
|
|
1898
|
+
def european_citizenship(self, value: Optional[pulumi.Input[str]]):
|
|
1899
|
+
pulumi.set(self, "european_citizenship", value)
|
|
1900
|
+
|
|
1901
|
+
|
|
1902
|
+
if not MYPY:
|
|
1903
|
+
class RegistrationOwnerContactExtensionFrArgsDict(TypedDict):
|
|
1904
|
+
association_info: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionFrAssociationInfoArgsDict']]
|
|
1905
|
+
"""
|
|
1906
|
+
Association-specific information for the domain (French extension).
|
|
1907
|
+
"""
|
|
1908
|
+
code_auth_afnic_info: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgsDict']]
|
|
1909
|
+
"""
|
|
1910
|
+
AFNIC authorization information for the contact (French extension).
|
|
1911
|
+
"""
|
|
1912
|
+
duns_info: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionFrDunsInfoArgsDict']]
|
|
1913
|
+
"""
|
|
1914
|
+
DUNS information for the domain owner (specific to French domains).
|
|
1915
|
+
"""
|
|
1916
|
+
individual_info: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionFrIndividualInfoArgsDict']]
|
|
1917
|
+
"""
|
|
1918
|
+
Information about the individual registration for French domains.
|
|
1919
|
+
"""
|
|
1920
|
+
mode: NotRequired[pulumi.Input[str]]
|
|
1921
|
+
"""
|
|
1922
|
+
Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
1923
|
+
"""
|
|
1924
|
+
trademark_info: NotRequired[pulumi.Input['RegistrationOwnerContactExtensionFrTrademarkInfoArgsDict']]
|
|
1925
|
+
"""
|
|
1926
|
+
Trademark-related information for the domain (French extension).
|
|
1927
|
+
"""
|
|
1928
|
+
elif False:
|
|
1929
|
+
RegistrationOwnerContactExtensionFrArgsDict: TypeAlias = Mapping[str, Any]
|
|
1930
|
+
|
|
1931
|
+
@pulumi.input_type
|
|
1932
|
+
class RegistrationOwnerContactExtensionFrArgs:
|
|
1933
|
+
def __init__(__self__, *,
|
|
1934
|
+
association_info: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrAssociationInfoArgs']] = None,
|
|
1935
|
+
code_auth_afnic_info: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgs']] = None,
|
|
1936
|
+
duns_info: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrDunsInfoArgs']] = None,
|
|
1937
|
+
individual_info: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrIndividualInfoArgs']] = None,
|
|
1938
|
+
mode: Optional[pulumi.Input[str]] = None,
|
|
1939
|
+
trademark_info: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrTrademarkInfoArgs']] = None):
|
|
1940
|
+
"""
|
|
1941
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionFrAssociationInfoArgs'] association_info: Association-specific information for the domain (French extension).
|
|
1942
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgs'] code_auth_afnic_info: AFNIC authorization information for the contact (French extension).
|
|
1943
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionFrDunsInfoArgs'] duns_info: DUNS information for the domain owner (specific to French domains).
|
|
1944
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionFrIndividualInfoArgs'] individual_info: Information about the individual registration for French domains.
|
|
1945
|
+
:param pulumi.Input[str] mode: Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
1946
|
+
:param pulumi.Input['RegistrationOwnerContactExtensionFrTrademarkInfoArgs'] trademark_info: Trademark-related information for the domain (French extension).
|
|
1947
|
+
"""
|
|
1948
|
+
if association_info is not None:
|
|
1949
|
+
pulumi.set(__self__, "association_info", association_info)
|
|
1950
|
+
if code_auth_afnic_info is not None:
|
|
1951
|
+
pulumi.set(__self__, "code_auth_afnic_info", code_auth_afnic_info)
|
|
1952
|
+
if duns_info is not None:
|
|
1953
|
+
pulumi.set(__self__, "duns_info", duns_info)
|
|
1954
|
+
if individual_info is not None:
|
|
1955
|
+
pulumi.set(__self__, "individual_info", individual_info)
|
|
1956
|
+
if mode is not None:
|
|
1957
|
+
pulumi.set(__self__, "mode", mode)
|
|
1958
|
+
if trademark_info is not None:
|
|
1959
|
+
pulumi.set(__self__, "trademark_info", trademark_info)
|
|
1960
|
+
|
|
1961
|
+
@property
|
|
1962
|
+
@pulumi.getter(name="associationInfo")
|
|
1963
|
+
def association_info(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionFrAssociationInfoArgs']]:
|
|
1964
|
+
"""
|
|
1965
|
+
Association-specific information for the domain (French extension).
|
|
1966
|
+
"""
|
|
1967
|
+
return pulumi.get(self, "association_info")
|
|
1968
|
+
|
|
1969
|
+
@association_info.setter
|
|
1970
|
+
def association_info(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrAssociationInfoArgs']]):
|
|
1971
|
+
pulumi.set(self, "association_info", value)
|
|
1972
|
+
|
|
1973
|
+
@property
|
|
1974
|
+
@pulumi.getter(name="codeAuthAfnicInfo")
|
|
1975
|
+
def code_auth_afnic_info(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgs']]:
|
|
1976
|
+
"""
|
|
1977
|
+
AFNIC authorization information for the contact (French extension).
|
|
1978
|
+
"""
|
|
1979
|
+
return pulumi.get(self, "code_auth_afnic_info")
|
|
1980
|
+
|
|
1981
|
+
@code_auth_afnic_info.setter
|
|
1982
|
+
def code_auth_afnic_info(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgs']]):
|
|
1983
|
+
pulumi.set(self, "code_auth_afnic_info", value)
|
|
1984
|
+
|
|
1985
|
+
@property
|
|
1986
|
+
@pulumi.getter(name="dunsInfo")
|
|
1987
|
+
def duns_info(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionFrDunsInfoArgs']]:
|
|
1988
|
+
"""
|
|
1989
|
+
DUNS information for the domain owner (specific to French domains).
|
|
1990
|
+
"""
|
|
1991
|
+
return pulumi.get(self, "duns_info")
|
|
1992
|
+
|
|
1993
|
+
@duns_info.setter
|
|
1994
|
+
def duns_info(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrDunsInfoArgs']]):
|
|
1995
|
+
pulumi.set(self, "duns_info", value)
|
|
1996
|
+
|
|
1997
|
+
@property
|
|
1998
|
+
@pulumi.getter(name="individualInfo")
|
|
1999
|
+
def individual_info(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionFrIndividualInfoArgs']]:
|
|
2000
|
+
"""
|
|
2001
|
+
Information about the individual registration for French domains.
|
|
2002
|
+
"""
|
|
2003
|
+
return pulumi.get(self, "individual_info")
|
|
2004
|
+
|
|
2005
|
+
@individual_info.setter
|
|
2006
|
+
def individual_info(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrIndividualInfoArgs']]):
|
|
2007
|
+
pulumi.set(self, "individual_info", value)
|
|
2008
|
+
|
|
2009
|
+
@property
|
|
2010
|
+
@pulumi.getter
|
|
2011
|
+
def mode(self) -> Optional[pulumi.Input[str]]:
|
|
2012
|
+
"""
|
|
2013
|
+
Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
2014
|
+
"""
|
|
2015
|
+
return pulumi.get(self, "mode")
|
|
2016
|
+
|
|
2017
|
+
@mode.setter
|
|
2018
|
+
def mode(self, value: Optional[pulumi.Input[str]]):
|
|
2019
|
+
pulumi.set(self, "mode", value)
|
|
2020
|
+
|
|
2021
|
+
@property
|
|
2022
|
+
@pulumi.getter(name="trademarkInfo")
|
|
2023
|
+
def trademark_info(self) -> Optional[pulumi.Input['RegistrationOwnerContactExtensionFrTrademarkInfoArgs']]:
|
|
2024
|
+
"""
|
|
2025
|
+
Trademark-related information for the domain (French extension).
|
|
2026
|
+
"""
|
|
2027
|
+
return pulumi.get(self, "trademark_info")
|
|
2028
|
+
|
|
2029
|
+
@trademark_info.setter
|
|
2030
|
+
def trademark_info(self, value: Optional[pulumi.Input['RegistrationOwnerContactExtensionFrTrademarkInfoArgs']]):
|
|
2031
|
+
pulumi.set(self, "trademark_info", value)
|
|
2032
|
+
|
|
2033
|
+
|
|
2034
|
+
if not MYPY:
|
|
2035
|
+
class RegistrationOwnerContactExtensionFrAssociationInfoArgsDict(TypedDict):
|
|
2036
|
+
publication_jo: NotRequired[pulumi.Input[str]]
|
|
2037
|
+
"""
|
|
2038
|
+
Publication date in the Official Journal (RFC3339 format) for association information.
|
|
2039
|
+
"""
|
|
2040
|
+
publication_jo_page: NotRequired[pulumi.Input[int]]
|
|
2041
|
+
"""
|
|
2042
|
+
Page number of the publication in the Official Journal for association information.
|
|
2043
|
+
"""
|
|
2044
|
+
elif False:
|
|
2045
|
+
RegistrationOwnerContactExtensionFrAssociationInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2046
|
+
|
|
2047
|
+
@pulumi.input_type
|
|
2048
|
+
class RegistrationOwnerContactExtensionFrAssociationInfoArgs:
|
|
2049
|
+
def __init__(__self__, *,
|
|
2050
|
+
publication_jo: Optional[pulumi.Input[str]] = None,
|
|
2051
|
+
publication_jo_page: Optional[pulumi.Input[int]] = None):
|
|
2052
|
+
"""
|
|
2053
|
+
:param pulumi.Input[str] publication_jo: Publication date in the Official Journal (RFC3339 format) for association information.
|
|
2054
|
+
:param pulumi.Input[int] publication_jo_page: Page number of the publication in the Official Journal for association information.
|
|
2055
|
+
"""
|
|
2056
|
+
if publication_jo is not None:
|
|
2057
|
+
pulumi.set(__self__, "publication_jo", publication_jo)
|
|
2058
|
+
if publication_jo_page is not None:
|
|
2059
|
+
pulumi.set(__self__, "publication_jo_page", publication_jo_page)
|
|
2060
|
+
|
|
2061
|
+
@property
|
|
2062
|
+
@pulumi.getter(name="publicationJo")
|
|
2063
|
+
def publication_jo(self) -> Optional[pulumi.Input[str]]:
|
|
2064
|
+
"""
|
|
2065
|
+
Publication date in the Official Journal (RFC3339 format) for association information.
|
|
2066
|
+
"""
|
|
2067
|
+
return pulumi.get(self, "publication_jo")
|
|
2068
|
+
|
|
2069
|
+
@publication_jo.setter
|
|
2070
|
+
def publication_jo(self, value: Optional[pulumi.Input[str]]):
|
|
2071
|
+
pulumi.set(self, "publication_jo", value)
|
|
2072
|
+
|
|
2073
|
+
@property
|
|
2074
|
+
@pulumi.getter(name="publicationJoPage")
|
|
2075
|
+
def publication_jo_page(self) -> Optional[pulumi.Input[int]]:
|
|
2076
|
+
"""
|
|
2077
|
+
Page number of the publication in the Official Journal for association information.
|
|
2078
|
+
"""
|
|
2079
|
+
return pulumi.get(self, "publication_jo_page")
|
|
2080
|
+
|
|
2081
|
+
@publication_jo_page.setter
|
|
2082
|
+
def publication_jo_page(self, value: Optional[pulumi.Input[int]]):
|
|
2083
|
+
pulumi.set(self, "publication_jo_page", value)
|
|
2084
|
+
|
|
2085
|
+
|
|
2086
|
+
if not MYPY:
|
|
2087
|
+
class RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgsDict(TypedDict):
|
|
2088
|
+
code_auth_afnic: NotRequired[pulumi.Input[str]]
|
|
2089
|
+
"""
|
|
2090
|
+
AFNIC authorization code for the contact (specific to French domains).
|
|
2091
|
+
"""
|
|
2092
|
+
elif False:
|
|
2093
|
+
RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2094
|
+
|
|
2095
|
+
@pulumi.input_type
|
|
2096
|
+
class RegistrationOwnerContactExtensionFrCodeAuthAfnicInfoArgs:
|
|
2097
|
+
def __init__(__self__, *,
|
|
2098
|
+
code_auth_afnic: Optional[pulumi.Input[str]] = None):
|
|
2099
|
+
"""
|
|
2100
|
+
:param pulumi.Input[str] code_auth_afnic: AFNIC authorization code for the contact (specific to French domains).
|
|
2101
|
+
"""
|
|
2102
|
+
if code_auth_afnic is not None:
|
|
2103
|
+
pulumi.set(__self__, "code_auth_afnic", code_auth_afnic)
|
|
2104
|
+
|
|
2105
|
+
@property
|
|
2106
|
+
@pulumi.getter(name="codeAuthAfnic")
|
|
2107
|
+
def code_auth_afnic(self) -> Optional[pulumi.Input[str]]:
|
|
2108
|
+
"""
|
|
2109
|
+
AFNIC authorization code for the contact (specific to French domains).
|
|
2110
|
+
"""
|
|
2111
|
+
return pulumi.get(self, "code_auth_afnic")
|
|
2112
|
+
|
|
2113
|
+
@code_auth_afnic.setter
|
|
2114
|
+
def code_auth_afnic(self, value: Optional[pulumi.Input[str]]):
|
|
2115
|
+
pulumi.set(self, "code_auth_afnic", value)
|
|
2116
|
+
|
|
2117
|
+
|
|
2118
|
+
if not MYPY:
|
|
2119
|
+
class RegistrationOwnerContactExtensionFrDunsInfoArgsDict(TypedDict):
|
|
2120
|
+
duns_id: NotRequired[pulumi.Input[str]]
|
|
2121
|
+
"""
|
|
2122
|
+
DUNS ID associated with the domain owner (for French domains).
|
|
2123
|
+
"""
|
|
2124
|
+
local_id: NotRequired[pulumi.Input[str]]
|
|
2125
|
+
"""
|
|
2126
|
+
Local identifier of the domain owner (for French domains).
|
|
2127
|
+
"""
|
|
2128
|
+
elif False:
|
|
2129
|
+
RegistrationOwnerContactExtensionFrDunsInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2130
|
+
|
|
2131
|
+
@pulumi.input_type
|
|
2132
|
+
class RegistrationOwnerContactExtensionFrDunsInfoArgs:
|
|
2133
|
+
def __init__(__self__, *,
|
|
2134
|
+
duns_id: Optional[pulumi.Input[str]] = None,
|
|
2135
|
+
local_id: Optional[pulumi.Input[str]] = None):
|
|
2136
|
+
"""
|
|
2137
|
+
:param pulumi.Input[str] duns_id: DUNS ID associated with the domain owner (for French domains).
|
|
2138
|
+
:param pulumi.Input[str] local_id: Local identifier of the domain owner (for French domains).
|
|
2139
|
+
"""
|
|
2140
|
+
if duns_id is not None:
|
|
2141
|
+
pulumi.set(__self__, "duns_id", duns_id)
|
|
2142
|
+
if local_id is not None:
|
|
2143
|
+
pulumi.set(__self__, "local_id", local_id)
|
|
2144
|
+
|
|
2145
|
+
@property
|
|
2146
|
+
@pulumi.getter(name="dunsId")
|
|
2147
|
+
def duns_id(self) -> Optional[pulumi.Input[str]]:
|
|
2148
|
+
"""
|
|
2149
|
+
DUNS ID associated with the domain owner (for French domains).
|
|
2150
|
+
"""
|
|
2151
|
+
return pulumi.get(self, "duns_id")
|
|
2152
|
+
|
|
2153
|
+
@duns_id.setter
|
|
2154
|
+
def duns_id(self, value: Optional[pulumi.Input[str]]):
|
|
2155
|
+
pulumi.set(self, "duns_id", value)
|
|
2156
|
+
|
|
2157
|
+
@property
|
|
2158
|
+
@pulumi.getter(name="localId")
|
|
2159
|
+
def local_id(self) -> Optional[pulumi.Input[str]]:
|
|
2160
|
+
"""
|
|
2161
|
+
Local identifier of the domain owner (for French domains).
|
|
2162
|
+
"""
|
|
2163
|
+
return pulumi.get(self, "local_id")
|
|
2164
|
+
|
|
2165
|
+
@local_id.setter
|
|
2166
|
+
def local_id(self, value: Optional[pulumi.Input[str]]):
|
|
2167
|
+
pulumi.set(self, "local_id", value)
|
|
2168
|
+
|
|
2169
|
+
|
|
2170
|
+
if not MYPY:
|
|
2171
|
+
class RegistrationOwnerContactExtensionFrIndividualInfoArgsDict(TypedDict):
|
|
2172
|
+
whois_opt_in: NotRequired[pulumi.Input[bool]]
|
|
2173
|
+
"""
|
|
2174
|
+
Whether the individual contact has opted into WHOIS publishing.
|
|
2175
|
+
"""
|
|
2176
|
+
elif False:
|
|
2177
|
+
RegistrationOwnerContactExtensionFrIndividualInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2178
|
+
|
|
2179
|
+
@pulumi.input_type
|
|
2180
|
+
class RegistrationOwnerContactExtensionFrIndividualInfoArgs:
|
|
2181
|
+
def __init__(__self__, *,
|
|
2182
|
+
whois_opt_in: Optional[pulumi.Input[bool]] = None):
|
|
2183
|
+
"""
|
|
2184
|
+
:param pulumi.Input[bool] whois_opt_in: Whether the individual contact has opted into WHOIS publishing.
|
|
2185
|
+
"""
|
|
2186
|
+
if whois_opt_in is not None:
|
|
2187
|
+
pulumi.set(__self__, "whois_opt_in", whois_opt_in)
|
|
2188
|
+
|
|
2189
|
+
@property
|
|
2190
|
+
@pulumi.getter(name="whoisOptIn")
|
|
2191
|
+
def whois_opt_in(self) -> Optional[pulumi.Input[bool]]:
|
|
2192
|
+
"""
|
|
2193
|
+
Whether the individual contact has opted into WHOIS publishing.
|
|
2194
|
+
"""
|
|
2195
|
+
return pulumi.get(self, "whois_opt_in")
|
|
2196
|
+
|
|
2197
|
+
@whois_opt_in.setter
|
|
2198
|
+
def whois_opt_in(self, value: Optional[pulumi.Input[bool]]):
|
|
2199
|
+
pulumi.set(self, "whois_opt_in", value)
|
|
2200
|
+
|
|
2201
|
+
|
|
2202
|
+
if not MYPY:
|
|
2203
|
+
class RegistrationOwnerContactExtensionFrTrademarkInfoArgsDict(TypedDict):
|
|
2204
|
+
trademark_inpi: NotRequired[pulumi.Input[str]]
|
|
2205
|
+
"""
|
|
2206
|
+
Trademark information from INPI (French extension).
|
|
2207
|
+
"""
|
|
2208
|
+
elif False:
|
|
2209
|
+
RegistrationOwnerContactExtensionFrTrademarkInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2210
|
+
|
|
2211
|
+
@pulumi.input_type
|
|
2212
|
+
class RegistrationOwnerContactExtensionFrTrademarkInfoArgs:
|
|
2213
|
+
def __init__(__self__, *,
|
|
2214
|
+
trademark_inpi: Optional[pulumi.Input[str]] = None):
|
|
2215
|
+
"""
|
|
2216
|
+
:param pulumi.Input[str] trademark_inpi: Trademark information from INPI (French extension).
|
|
2217
|
+
"""
|
|
2218
|
+
if trademark_inpi is not None:
|
|
2219
|
+
pulumi.set(__self__, "trademark_inpi", trademark_inpi)
|
|
2220
|
+
|
|
2221
|
+
@property
|
|
2222
|
+
@pulumi.getter(name="trademarkInpi")
|
|
2223
|
+
def trademark_inpi(self) -> Optional[pulumi.Input[str]]:
|
|
2224
|
+
"""
|
|
2225
|
+
Trademark information from INPI (French extension).
|
|
2226
|
+
"""
|
|
2227
|
+
return pulumi.get(self, "trademark_inpi")
|
|
2228
|
+
|
|
2229
|
+
@trademark_inpi.setter
|
|
2230
|
+
def trademark_inpi(self, value: Optional[pulumi.Input[str]]):
|
|
2231
|
+
pulumi.set(self, "trademark_inpi", value)
|
|
2232
|
+
|
|
2233
|
+
|
|
2234
|
+
if not MYPY:
|
|
2235
|
+
class RegistrationTechnicalContactArgsDict(TypedDict):
|
|
2236
|
+
address_line1: pulumi.Input[str]
|
|
2237
|
+
"""
|
|
2238
|
+
Primary address line for the contact.
|
|
2239
|
+
"""
|
|
2240
|
+
city: pulumi.Input[str]
|
|
2241
|
+
"""
|
|
2242
|
+
City of the contact's address.
|
|
2243
|
+
"""
|
|
2244
|
+
company_identification_code: pulumi.Input[str]
|
|
2245
|
+
"""
|
|
2246
|
+
Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
2247
|
+
"""
|
|
2248
|
+
country: pulumi.Input[str]
|
|
2249
|
+
"""
|
|
2250
|
+
Country code of the contact's address (ISO format).
|
|
2251
|
+
"""
|
|
2252
|
+
email: pulumi.Input[str]
|
|
2253
|
+
"""
|
|
2254
|
+
Primary email address of the contact.
|
|
2255
|
+
"""
|
|
2256
|
+
firstname: pulumi.Input[str]
|
|
2257
|
+
"""
|
|
2258
|
+
First name of the contact.
|
|
2259
|
+
"""
|
|
2260
|
+
lastname: pulumi.Input[str]
|
|
2261
|
+
"""
|
|
2262
|
+
Last name of the contact.
|
|
2263
|
+
"""
|
|
2264
|
+
legal_form: pulumi.Input[str]
|
|
2265
|
+
"""
|
|
2266
|
+
Legal form of the contact (e.g., 'individual' or 'organization').
|
|
2267
|
+
"""
|
|
2268
|
+
phone_number: pulumi.Input[str]
|
|
2269
|
+
"""
|
|
2270
|
+
Primary phone number of the contact.
|
|
2271
|
+
"""
|
|
2272
|
+
vat_identification_code: pulumi.Input[str]
|
|
2273
|
+
"""
|
|
2274
|
+
VAT identification code of the contact, if applicable.
|
|
2275
|
+
"""
|
|
2276
|
+
zip: pulumi.Input[str]
|
|
2277
|
+
"""
|
|
2278
|
+
Postal code of the contact's address.
|
|
2279
|
+
"""
|
|
2280
|
+
address_line2: NotRequired[pulumi.Input[str]]
|
|
2281
|
+
"""
|
|
2282
|
+
Secondary address line for the contact (optional).
|
|
2283
|
+
"""
|
|
2284
|
+
company_name: NotRequired[pulumi.Input[str]]
|
|
2285
|
+
"""
|
|
2286
|
+
Name of the company associated with the contact (if applicable).
|
|
2287
|
+
"""
|
|
2288
|
+
email_alt: NotRequired[pulumi.Input[str]]
|
|
2289
|
+
"""
|
|
2290
|
+
Alternative email address for the contact.
|
|
2291
|
+
"""
|
|
2292
|
+
extension_eu: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionEuArgsDict']]
|
|
2293
|
+
"""
|
|
2294
|
+
Details specific to European domain extensions.
|
|
2295
|
+
"""
|
|
2296
|
+
extension_fr: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionFrArgsDict']]
|
|
2297
|
+
"""
|
|
2298
|
+
Details specific to French domain extensions.
|
|
2299
|
+
"""
|
|
2300
|
+
extension_nls: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2301
|
+
"""
|
|
2302
|
+
Extension details specific to Dutch domain registrations.
|
|
2303
|
+
"""
|
|
2304
|
+
fax_number: NotRequired[pulumi.Input[str]]
|
|
2305
|
+
"""
|
|
2306
|
+
Fax number for the contact (if available).
|
|
2307
|
+
"""
|
|
2308
|
+
lang: NotRequired[pulumi.Input[str]]
|
|
2309
|
+
"""
|
|
2310
|
+
Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
2311
|
+
"""
|
|
2312
|
+
resale: NotRequired[pulumi.Input[bool]]
|
|
2313
|
+
"""
|
|
2314
|
+
Indicates if the contact is used for resale purposes.
|
|
2315
|
+
"""
|
|
2316
|
+
state: NotRequired[pulumi.Input[str]]
|
|
2317
|
+
"""
|
|
2318
|
+
State or region of the contact.
|
|
2319
|
+
"""
|
|
2320
|
+
whois_opt_in: NotRequired[pulumi.Input[bool]]
|
|
2321
|
+
"""
|
|
2322
|
+
Indicates whether the contact has opted into WHOIS publishing.
|
|
2323
|
+
"""
|
|
2324
|
+
elif False:
|
|
2325
|
+
RegistrationTechnicalContactArgsDict: TypeAlias = Mapping[str, Any]
|
|
2326
|
+
|
|
2327
|
+
@pulumi.input_type
|
|
2328
|
+
class RegistrationTechnicalContactArgs:
|
|
2329
|
+
def __init__(__self__, *,
|
|
2330
|
+
address_line1: pulumi.Input[str],
|
|
2331
|
+
city: pulumi.Input[str],
|
|
2332
|
+
company_identification_code: pulumi.Input[str],
|
|
2333
|
+
country: pulumi.Input[str],
|
|
2334
|
+
email: pulumi.Input[str],
|
|
2335
|
+
firstname: pulumi.Input[str],
|
|
2336
|
+
lastname: pulumi.Input[str],
|
|
2337
|
+
legal_form: pulumi.Input[str],
|
|
2338
|
+
phone_number: pulumi.Input[str],
|
|
2339
|
+
vat_identification_code: pulumi.Input[str],
|
|
2340
|
+
zip: pulumi.Input[str],
|
|
2341
|
+
address_line2: Optional[pulumi.Input[str]] = None,
|
|
2342
|
+
company_name: Optional[pulumi.Input[str]] = None,
|
|
2343
|
+
email_alt: Optional[pulumi.Input[str]] = None,
|
|
2344
|
+
extension_eu: Optional[pulumi.Input['RegistrationTechnicalContactExtensionEuArgs']] = None,
|
|
2345
|
+
extension_fr: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrArgs']] = None,
|
|
2346
|
+
extension_nls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2347
|
+
fax_number: Optional[pulumi.Input[str]] = None,
|
|
2348
|
+
lang: Optional[pulumi.Input[str]] = None,
|
|
2349
|
+
resale: Optional[pulumi.Input[bool]] = None,
|
|
2350
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
2351
|
+
whois_opt_in: Optional[pulumi.Input[bool]] = None):
|
|
2352
|
+
"""
|
|
2353
|
+
:param pulumi.Input[str] address_line1: Primary address line for the contact.
|
|
2354
|
+
:param pulumi.Input[str] city: City of the contact's address.
|
|
2355
|
+
:param pulumi.Input[str] company_identification_code: Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
2356
|
+
:param pulumi.Input[str] country: Country code of the contact's address (ISO format).
|
|
2357
|
+
:param pulumi.Input[str] email: Primary email address of the contact.
|
|
2358
|
+
:param pulumi.Input[str] firstname: First name of the contact.
|
|
2359
|
+
:param pulumi.Input[str] lastname: Last name of the contact.
|
|
2360
|
+
:param pulumi.Input[str] legal_form: Legal form of the contact (e.g., 'individual' or 'organization').
|
|
2361
|
+
:param pulumi.Input[str] phone_number: Primary phone number of the contact.
|
|
2362
|
+
:param pulumi.Input[str] vat_identification_code: VAT identification code of the contact, if applicable.
|
|
2363
|
+
:param pulumi.Input[str] zip: Postal code of the contact's address.
|
|
2364
|
+
:param pulumi.Input[str] address_line2: Secondary address line for the contact (optional).
|
|
2365
|
+
:param pulumi.Input[str] company_name: Name of the company associated with the contact (if applicable).
|
|
2366
|
+
:param pulumi.Input[str] email_alt: Alternative email address for the contact.
|
|
2367
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionEuArgs'] extension_eu: Details specific to European domain extensions.
|
|
2368
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionFrArgs'] extension_fr: Details specific to French domain extensions.
|
|
2369
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] extension_nls: Extension details specific to Dutch domain registrations.
|
|
2370
|
+
:param pulumi.Input[str] fax_number: Fax number for the contact (if available).
|
|
2371
|
+
:param pulumi.Input[str] lang: Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
2372
|
+
:param pulumi.Input[bool] resale: Indicates if the contact is used for resale purposes.
|
|
2373
|
+
:param pulumi.Input[str] state: State or region of the contact.
|
|
2374
|
+
:param pulumi.Input[bool] whois_opt_in: Indicates whether the contact has opted into WHOIS publishing.
|
|
2375
|
+
"""
|
|
2376
|
+
pulumi.set(__self__, "address_line1", address_line1)
|
|
2377
|
+
pulumi.set(__self__, "city", city)
|
|
2378
|
+
pulumi.set(__self__, "company_identification_code", company_identification_code)
|
|
2379
|
+
pulumi.set(__self__, "country", country)
|
|
2380
|
+
pulumi.set(__self__, "email", email)
|
|
2381
|
+
pulumi.set(__self__, "firstname", firstname)
|
|
2382
|
+
pulumi.set(__self__, "lastname", lastname)
|
|
2383
|
+
pulumi.set(__self__, "legal_form", legal_form)
|
|
2384
|
+
pulumi.set(__self__, "phone_number", phone_number)
|
|
2385
|
+
pulumi.set(__self__, "vat_identification_code", vat_identification_code)
|
|
2386
|
+
pulumi.set(__self__, "zip", zip)
|
|
2387
|
+
if address_line2 is not None:
|
|
2388
|
+
pulumi.set(__self__, "address_line2", address_line2)
|
|
2389
|
+
if company_name is not None:
|
|
2390
|
+
pulumi.set(__self__, "company_name", company_name)
|
|
2391
|
+
if email_alt is not None:
|
|
2392
|
+
pulumi.set(__self__, "email_alt", email_alt)
|
|
2393
|
+
if extension_eu is not None:
|
|
2394
|
+
pulumi.set(__self__, "extension_eu", extension_eu)
|
|
2395
|
+
if extension_fr is not None:
|
|
2396
|
+
pulumi.set(__self__, "extension_fr", extension_fr)
|
|
2397
|
+
if extension_nls is not None:
|
|
2398
|
+
pulumi.set(__self__, "extension_nls", extension_nls)
|
|
2399
|
+
if fax_number is not None:
|
|
2400
|
+
pulumi.set(__self__, "fax_number", fax_number)
|
|
2401
|
+
if lang is not None:
|
|
2402
|
+
pulumi.set(__self__, "lang", lang)
|
|
2403
|
+
if resale is not None:
|
|
2404
|
+
pulumi.set(__self__, "resale", resale)
|
|
2405
|
+
if state is not None:
|
|
2406
|
+
pulumi.set(__self__, "state", state)
|
|
2407
|
+
if whois_opt_in is not None:
|
|
2408
|
+
pulumi.set(__self__, "whois_opt_in", whois_opt_in)
|
|
2409
|
+
|
|
2410
|
+
@property
|
|
2411
|
+
@pulumi.getter(name="addressLine1")
|
|
2412
|
+
def address_line1(self) -> pulumi.Input[str]:
|
|
2413
|
+
"""
|
|
2414
|
+
Primary address line for the contact.
|
|
2415
|
+
"""
|
|
2416
|
+
return pulumi.get(self, "address_line1")
|
|
2417
|
+
|
|
2418
|
+
@address_line1.setter
|
|
2419
|
+
def address_line1(self, value: pulumi.Input[str]):
|
|
2420
|
+
pulumi.set(self, "address_line1", value)
|
|
2421
|
+
|
|
2422
|
+
@property
|
|
2423
|
+
@pulumi.getter
|
|
2424
|
+
def city(self) -> pulumi.Input[str]:
|
|
2425
|
+
"""
|
|
2426
|
+
City of the contact's address.
|
|
2427
|
+
"""
|
|
2428
|
+
return pulumi.get(self, "city")
|
|
2429
|
+
|
|
2430
|
+
@city.setter
|
|
2431
|
+
def city(self, value: pulumi.Input[str]):
|
|
2432
|
+
pulumi.set(self, "city", value)
|
|
2433
|
+
|
|
2434
|
+
@property
|
|
2435
|
+
@pulumi.getter(name="companyIdentificationCode")
|
|
2436
|
+
def company_identification_code(self) -> pulumi.Input[str]:
|
|
2437
|
+
"""
|
|
2438
|
+
Company identification code (e.g., SIREN/SIRET in France) for the contact.
|
|
2439
|
+
"""
|
|
2440
|
+
return pulumi.get(self, "company_identification_code")
|
|
2441
|
+
|
|
2442
|
+
@company_identification_code.setter
|
|
2443
|
+
def company_identification_code(self, value: pulumi.Input[str]):
|
|
2444
|
+
pulumi.set(self, "company_identification_code", value)
|
|
2445
|
+
|
|
2446
|
+
@property
|
|
2447
|
+
@pulumi.getter
|
|
2448
|
+
def country(self) -> pulumi.Input[str]:
|
|
2449
|
+
"""
|
|
2450
|
+
Country code of the contact's address (ISO format).
|
|
2451
|
+
"""
|
|
2452
|
+
return pulumi.get(self, "country")
|
|
2453
|
+
|
|
2454
|
+
@country.setter
|
|
2455
|
+
def country(self, value: pulumi.Input[str]):
|
|
2456
|
+
pulumi.set(self, "country", value)
|
|
2457
|
+
|
|
2458
|
+
@property
|
|
2459
|
+
@pulumi.getter
|
|
2460
|
+
def email(self) -> pulumi.Input[str]:
|
|
2461
|
+
"""
|
|
2462
|
+
Primary email address of the contact.
|
|
2463
|
+
"""
|
|
2464
|
+
return pulumi.get(self, "email")
|
|
2465
|
+
|
|
2466
|
+
@email.setter
|
|
2467
|
+
def email(self, value: pulumi.Input[str]):
|
|
2468
|
+
pulumi.set(self, "email", value)
|
|
2469
|
+
|
|
2470
|
+
@property
|
|
2471
|
+
@pulumi.getter
|
|
2472
|
+
def firstname(self) -> pulumi.Input[str]:
|
|
2473
|
+
"""
|
|
2474
|
+
First name of the contact.
|
|
2475
|
+
"""
|
|
2476
|
+
return pulumi.get(self, "firstname")
|
|
2477
|
+
|
|
2478
|
+
@firstname.setter
|
|
2479
|
+
def firstname(self, value: pulumi.Input[str]):
|
|
2480
|
+
pulumi.set(self, "firstname", value)
|
|
2481
|
+
|
|
2482
|
+
@property
|
|
2483
|
+
@pulumi.getter
|
|
2484
|
+
def lastname(self) -> pulumi.Input[str]:
|
|
2485
|
+
"""
|
|
2486
|
+
Last name of the contact.
|
|
2487
|
+
"""
|
|
2488
|
+
return pulumi.get(self, "lastname")
|
|
2489
|
+
|
|
2490
|
+
@lastname.setter
|
|
2491
|
+
def lastname(self, value: pulumi.Input[str]):
|
|
2492
|
+
pulumi.set(self, "lastname", value)
|
|
2493
|
+
|
|
2494
|
+
@property
|
|
2495
|
+
@pulumi.getter(name="legalForm")
|
|
2496
|
+
def legal_form(self) -> pulumi.Input[str]:
|
|
2497
|
+
"""
|
|
2498
|
+
Legal form of the contact (e.g., 'individual' or 'organization').
|
|
2499
|
+
"""
|
|
2500
|
+
return pulumi.get(self, "legal_form")
|
|
2501
|
+
|
|
2502
|
+
@legal_form.setter
|
|
2503
|
+
def legal_form(self, value: pulumi.Input[str]):
|
|
2504
|
+
pulumi.set(self, "legal_form", value)
|
|
2505
|
+
|
|
2506
|
+
@property
|
|
2507
|
+
@pulumi.getter(name="phoneNumber")
|
|
2508
|
+
def phone_number(self) -> pulumi.Input[str]:
|
|
2509
|
+
"""
|
|
2510
|
+
Primary phone number of the contact.
|
|
2511
|
+
"""
|
|
2512
|
+
return pulumi.get(self, "phone_number")
|
|
2513
|
+
|
|
2514
|
+
@phone_number.setter
|
|
2515
|
+
def phone_number(self, value: pulumi.Input[str]):
|
|
2516
|
+
pulumi.set(self, "phone_number", value)
|
|
2517
|
+
|
|
2518
|
+
@property
|
|
2519
|
+
@pulumi.getter(name="vatIdentificationCode")
|
|
2520
|
+
def vat_identification_code(self) -> pulumi.Input[str]:
|
|
2521
|
+
"""
|
|
2522
|
+
VAT identification code of the contact, if applicable.
|
|
2523
|
+
"""
|
|
2524
|
+
return pulumi.get(self, "vat_identification_code")
|
|
2525
|
+
|
|
2526
|
+
@vat_identification_code.setter
|
|
2527
|
+
def vat_identification_code(self, value: pulumi.Input[str]):
|
|
2528
|
+
pulumi.set(self, "vat_identification_code", value)
|
|
2529
|
+
|
|
2530
|
+
@property
|
|
2531
|
+
@pulumi.getter
|
|
2532
|
+
def zip(self) -> pulumi.Input[str]:
|
|
2533
|
+
"""
|
|
2534
|
+
Postal code of the contact's address.
|
|
2535
|
+
"""
|
|
2536
|
+
return pulumi.get(self, "zip")
|
|
2537
|
+
|
|
2538
|
+
@zip.setter
|
|
2539
|
+
def zip(self, value: pulumi.Input[str]):
|
|
2540
|
+
pulumi.set(self, "zip", value)
|
|
2541
|
+
|
|
2542
|
+
@property
|
|
2543
|
+
@pulumi.getter(name="addressLine2")
|
|
2544
|
+
def address_line2(self) -> Optional[pulumi.Input[str]]:
|
|
2545
|
+
"""
|
|
2546
|
+
Secondary address line for the contact (optional).
|
|
2547
|
+
"""
|
|
2548
|
+
return pulumi.get(self, "address_line2")
|
|
2549
|
+
|
|
2550
|
+
@address_line2.setter
|
|
2551
|
+
def address_line2(self, value: Optional[pulumi.Input[str]]):
|
|
2552
|
+
pulumi.set(self, "address_line2", value)
|
|
2553
|
+
|
|
2554
|
+
@property
|
|
2555
|
+
@pulumi.getter(name="companyName")
|
|
2556
|
+
def company_name(self) -> Optional[pulumi.Input[str]]:
|
|
2557
|
+
"""
|
|
2558
|
+
Name of the company associated with the contact (if applicable).
|
|
2559
|
+
"""
|
|
2560
|
+
return pulumi.get(self, "company_name")
|
|
2561
|
+
|
|
2562
|
+
@company_name.setter
|
|
2563
|
+
def company_name(self, value: Optional[pulumi.Input[str]]):
|
|
2564
|
+
pulumi.set(self, "company_name", value)
|
|
2565
|
+
|
|
2566
|
+
@property
|
|
2567
|
+
@pulumi.getter(name="emailAlt")
|
|
2568
|
+
def email_alt(self) -> Optional[pulumi.Input[str]]:
|
|
2569
|
+
"""
|
|
2570
|
+
Alternative email address for the contact.
|
|
2571
|
+
"""
|
|
2572
|
+
return pulumi.get(self, "email_alt")
|
|
2573
|
+
|
|
2574
|
+
@email_alt.setter
|
|
2575
|
+
def email_alt(self, value: Optional[pulumi.Input[str]]):
|
|
2576
|
+
pulumi.set(self, "email_alt", value)
|
|
2577
|
+
|
|
2578
|
+
@property
|
|
2579
|
+
@pulumi.getter(name="extensionEu")
|
|
2580
|
+
def extension_eu(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionEuArgs']]:
|
|
2581
|
+
"""
|
|
2582
|
+
Details specific to European domain extensions.
|
|
2583
|
+
"""
|
|
2584
|
+
return pulumi.get(self, "extension_eu")
|
|
2585
|
+
|
|
2586
|
+
@extension_eu.setter
|
|
2587
|
+
def extension_eu(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionEuArgs']]):
|
|
2588
|
+
pulumi.set(self, "extension_eu", value)
|
|
2589
|
+
|
|
2590
|
+
@property
|
|
2591
|
+
@pulumi.getter(name="extensionFr")
|
|
2592
|
+
def extension_fr(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrArgs']]:
|
|
2593
|
+
"""
|
|
2594
|
+
Details specific to French domain extensions.
|
|
2595
|
+
"""
|
|
2596
|
+
return pulumi.get(self, "extension_fr")
|
|
2597
|
+
|
|
2598
|
+
@extension_fr.setter
|
|
2599
|
+
def extension_fr(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrArgs']]):
|
|
2600
|
+
pulumi.set(self, "extension_fr", value)
|
|
2601
|
+
|
|
2602
|
+
@property
|
|
2603
|
+
@pulumi.getter(name="extensionNls")
|
|
2604
|
+
def extension_nls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2605
|
+
"""
|
|
2606
|
+
Extension details specific to Dutch domain registrations.
|
|
2607
|
+
"""
|
|
2608
|
+
return pulumi.get(self, "extension_nls")
|
|
2609
|
+
|
|
2610
|
+
@extension_nls.setter
|
|
2611
|
+
def extension_nls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2612
|
+
pulumi.set(self, "extension_nls", value)
|
|
2613
|
+
|
|
2614
|
+
@property
|
|
2615
|
+
@pulumi.getter(name="faxNumber")
|
|
2616
|
+
def fax_number(self) -> Optional[pulumi.Input[str]]:
|
|
2617
|
+
"""
|
|
2618
|
+
Fax number for the contact (if available).
|
|
2619
|
+
"""
|
|
2620
|
+
return pulumi.get(self, "fax_number")
|
|
2621
|
+
|
|
2622
|
+
@fax_number.setter
|
|
2623
|
+
def fax_number(self, value: Optional[pulumi.Input[str]]):
|
|
2624
|
+
pulumi.set(self, "fax_number", value)
|
|
2625
|
+
|
|
2626
|
+
@property
|
|
2627
|
+
@pulumi.getter
|
|
2628
|
+
def lang(self) -> Optional[pulumi.Input[str]]:
|
|
2629
|
+
"""
|
|
2630
|
+
Preferred language of the contact (e.g., 'en_US', 'fr_FR').
|
|
2631
|
+
"""
|
|
2632
|
+
return pulumi.get(self, "lang")
|
|
2633
|
+
|
|
2634
|
+
@lang.setter
|
|
2635
|
+
def lang(self, value: Optional[pulumi.Input[str]]):
|
|
2636
|
+
pulumi.set(self, "lang", value)
|
|
2637
|
+
|
|
2638
|
+
@property
|
|
2639
|
+
@pulumi.getter
|
|
2640
|
+
def resale(self) -> Optional[pulumi.Input[bool]]:
|
|
2641
|
+
"""
|
|
2642
|
+
Indicates if the contact is used for resale purposes.
|
|
2643
|
+
"""
|
|
2644
|
+
return pulumi.get(self, "resale")
|
|
2645
|
+
|
|
2646
|
+
@resale.setter
|
|
2647
|
+
def resale(self, value: Optional[pulumi.Input[bool]]):
|
|
2648
|
+
pulumi.set(self, "resale", value)
|
|
2649
|
+
|
|
2650
|
+
@property
|
|
2651
|
+
@pulumi.getter
|
|
2652
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
2653
|
+
"""
|
|
2654
|
+
State or region of the contact.
|
|
2655
|
+
"""
|
|
2656
|
+
return pulumi.get(self, "state")
|
|
2657
|
+
|
|
2658
|
+
@state.setter
|
|
2659
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
2660
|
+
pulumi.set(self, "state", value)
|
|
2661
|
+
|
|
2662
|
+
@property
|
|
2663
|
+
@pulumi.getter(name="whoisOptIn")
|
|
2664
|
+
def whois_opt_in(self) -> Optional[pulumi.Input[bool]]:
|
|
2665
|
+
"""
|
|
2666
|
+
Indicates whether the contact has opted into WHOIS publishing.
|
|
2667
|
+
"""
|
|
2668
|
+
return pulumi.get(self, "whois_opt_in")
|
|
2669
|
+
|
|
2670
|
+
@whois_opt_in.setter
|
|
2671
|
+
def whois_opt_in(self, value: Optional[pulumi.Input[bool]]):
|
|
2672
|
+
pulumi.set(self, "whois_opt_in", value)
|
|
2673
|
+
|
|
2674
|
+
|
|
2675
|
+
if not MYPY:
|
|
2676
|
+
class RegistrationTechnicalContactExtensionEuArgsDict(TypedDict):
|
|
2677
|
+
european_citizenship: NotRequired[pulumi.Input[str]]
|
|
2678
|
+
"""
|
|
2679
|
+
Indicates the European citizenship of the contact.
|
|
2680
|
+
"""
|
|
2681
|
+
elif False:
|
|
2682
|
+
RegistrationTechnicalContactExtensionEuArgsDict: TypeAlias = Mapping[str, Any]
|
|
2683
|
+
|
|
2684
|
+
@pulumi.input_type
|
|
2685
|
+
class RegistrationTechnicalContactExtensionEuArgs:
|
|
2686
|
+
def __init__(__self__, *,
|
|
2687
|
+
european_citizenship: Optional[pulumi.Input[str]] = None):
|
|
2688
|
+
"""
|
|
2689
|
+
:param pulumi.Input[str] european_citizenship: Indicates the European citizenship of the contact.
|
|
2690
|
+
"""
|
|
2691
|
+
if european_citizenship is not None:
|
|
2692
|
+
pulumi.set(__self__, "european_citizenship", european_citizenship)
|
|
2693
|
+
|
|
2694
|
+
@property
|
|
2695
|
+
@pulumi.getter(name="europeanCitizenship")
|
|
2696
|
+
def european_citizenship(self) -> Optional[pulumi.Input[str]]:
|
|
2697
|
+
"""
|
|
2698
|
+
Indicates the European citizenship of the contact.
|
|
2699
|
+
"""
|
|
2700
|
+
return pulumi.get(self, "european_citizenship")
|
|
2701
|
+
|
|
2702
|
+
@european_citizenship.setter
|
|
2703
|
+
def european_citizenship(self, value: Optional[pulumi.Input[str]]):
|
|
2704
|
+
pulumi.set(self, "european_citizenship", value)
|
|
2705
|
+
|
|
2706
|
+
|
|
2707
|
+
if not MYPY:
|
|
2708
|
+
class RegistrationTechnicalContactExtensionFrArgsDict(TypedDict):
|
|
2709
|
+
association_info: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionFrAssociationInfoArgsDict']]
|
|
2710
|
+
"""
|
|
2711
|
+
Association-specific information for the domain (French extension).
|
|
2712
|
+
"""
|
|
2713
|
+
code_auth_afnic_info: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgsDict']]
|
|
2714
|
+
"""
|
|
2715
|
+
AFNIC authorization information for the contact (French extension).
|
|
2716
|
+
"""
|
|
2717
|
+
duns_info: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionFrDunsInfoArgsDict']]
|
|
2718
|
+
"""
|
|
2719
|
+
DUNS information for the domain owner (specific to French domains).
|
|
2720
|
+
"""
|
|
2721
|
+
individual_info: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionFrIndividualInfoArgsDict']]
|
|
2722
|
+
"""
|
|
2723
|
+
Information about the individual registration for French domains.
|
|
2724
|
+
"""
|
|
2725
|
+
mode: NotRequired[pulumi.Input[str]]
|
|
2726
|
+
"""
|
|
2727
|
+
Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
2728
|
+
"""
|
|
2729
|
+
trademark_info: NotRequired[pulumi.Input['RegistrationTechnicalContactExtensionFrTrademarkInfoArgsDict']]
|
|
2730
|
+
"""
|
|
2731
|
+
Trademark-related information for the domain (French extension).
|
|
2732
|
+
"""
|
|
2733
|
+
elif False:
|
|
2734
|
+
RegistrationTechnicalContactExtensionFrArgsDict: TypeAlias = Mapping[str, Any]
|
|
2735
|
+
|
|
2736
|
+
@pulumi.input_type
|
|
2737
|
+
class RegistrationTechnicalContactExtensionFrArgs:
|
|
2738
|
+
def __init__(__self__, *,
|
|
2739
|
+
association_info: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrAssociationInfoArgs']] = None,
|
|
2740
|
+
code_auth_afnic_info: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgs']] = None,
|
|
2741
|
+
duns_info: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrDunsInfoArgs']] = None,
|
|
2742
|
+
individual_info: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrIndividualInfoArgs']] = None,
|
|
2743
|
+
mode: Optional[pulumi.Input[str]] = None,
|
|
2744
|
+
trademark_info: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrTrademarkInfoArgs']] = None):
|
|
2745
|
+
"""
|
|
2746
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionFrAssociationInfoArgs'] association_info: Association-specific information for the domain (French extension).
|
|
2747
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgs'] code_auth_afnic_info: AFNIC authorization information for the contact (French extension).
|
|
2748
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionFrDunsInfoArgs'] duns_info: DUNS information for the domain owner (specific to French domains).
|
|
2749
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionFrIndividualInfoArgs'] individual_info: Information about the individual registration for French domains.
|
|
2750
|
+
:param pulumi.Input[str] mode: Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
2751
|
+
:param pulumi.Input['RegistrationTechnicalContactExtensionFrTrademarkInfoArgs'] trademark_info: Trademark-related information for the domain (French extension).
|
|
2752
|
+
"""
|
|
2753
|
+
if association_info is not None:
|
|
2754
|
+
pulumi.set(__self__, "association_info", association_info)
|
|
2755
|
+
if code_auth_afnic_info is not None:
|
|
2756
|
+
pulumi.set(__self__, "code_auth_afnic_info", code_auth_afnic_info)
|
|
2757
|
+
if duns_info is not None:
|
|
2758
|
+
pulumi.set(__self__, "duns_info", duns_info)
|
|
2759
|
+
if individual_info is not None:
|
|
2760
|
+
pulumi.set(__self__, "individual_info", individual_info)
|
|
2761
|
+
if mode is not None:
|
|
2762
|
+
pulumi.set(__self__, "mode", mode)
|
|
2763
|
+
if trademark_info is not None:
|
|
2764
|
+
pulumi.set(__self__, "trademark_info", trademark_info)
|
|
2765
|
+
|
|
2766
|
+
@property
|
|
2767
|
+
@pulumi.getter(name="associationInfo")
|
|
2768
|
+
def association_info(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrAssociationInfoArgs']]:
|
|
2769
|
+
"""
|
|
2770
|
+
Association-specific information for the domain (French extension).
|
|
2771
|
+
"""
|
|
2772
|
+
return pulumi.get(self, "association_info")
|
|
2773
|
+
|
|
2774
|
+
@association_info.setter
|
|
2775
|
+
def association_info(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrAssociationInfoArgs']]):
|
|
2776
|
+
pulumi.set(self, "association_info", value)
|
|
2777
|
+
|
|
2778
|
+
@property
|
|
2779
|
+
@pulumi.getter(name="codeAuthAfnicInfo")
|
|
2780
|
+
def code_auth_afnic_info(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgs']]:
|
|
2781
|
+
"""
|
|
2782
|
+
AFNIC authorization information for the contact (French extension).
|
|
2783
|
+
"""
|
|
2784
|
+
return pulumi.get(self, "code_auth_afnic_info")
|
|
2785
|
+
|
|
2786
|
+
@code_auth_afnic_info.setter
|
|
2787
|
+
def code_auth_afnic_info(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgs']]):
|
|
2788
|
+
pulumi.set(self, "code_auth_afnic_info", value)
|
|
2789
|
+
|
|
2790
|
+
@property
|
|
2791
|
+
@pulumi.getter(name="dunsInfo")
|
|
2792
|
+
def duns_info(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrDunsInfoArgs']]:
|
|
2793
|
+
"""
|
|
2794
|
+
DUNS information for the domain owner (specific to French domains).
|
|
2795
|
+
"""
|
|
2796
|
+
return pulumi.get(self, "duns_info")
|
|
2797
|
+
|
|
2798
|
+
@duns_info.setter
|
|
2799
|
+
def duns_info(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrDunsInfoArgs']]):
|
|
2800
|
+
pulumi.set(self, "duns_info", value)
|
|
2801
|
+
|
|
2802
|
+
@property
|
|
2803
|
+
@pulumi.getter(name="individualInfo")
|
|
2804
|
+
def individual_info(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrIndividualInfoArgs']]:
|
|
2805
|
+
"""
|
|
2806
|
+
Information about the individual registration for French domains.
|
|
2807
|
+
"""
|
|
2808
|
+
return pulumi.get(self, "individual_info")
|
|
2809
|
+
|
|
2810
|
+
@individual_info.setter
|
|
2811
|
+
def individual_info(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrIndividualInfoArgs']]):
|
|
2812
|
+
pulumi.set(self, "individual_info", value)
|
|
2813
|
+
|
|
2814
|
+
@property
|
|
2815
|
+
@pulumi.getter
|
|
2816
|
+
def mode(self) -> Optional[pulumi.Input[str]]:
|
|
2817
|
+
"""
|
|
2818
|
+
Mode of the French extension (e.g., 'individual', 'duns', 'association', etc.).
|
|
2819
|
+
"""
|
|
2820
|
+
return pulumi.get(self, "mode")
|
|
2821
|
+
|
|
2822
|
+
@mode.setter
|
|
2823
|
+
def mode(self, value: Optional[pulumi.Input[str]]):
|
|
2824
|
+
pulumi.set(self, "mode", value)
|
|
2825
|
+
|
|
2826
|
+
@property
|
|
2827
|
+
@pulumi.getter(name="trademarkInfo")
|
|
2828
|
+
def trademark_info(self) -> Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrTrademarkInfoArgs']]:
|
|
2829
|
+
"""
|
|
2830
|
+
Trademark-related information for the domain (French extension).
|
|
2831
|
+
"""
|
|
2832
|
+
return pulumi.get(self, "trademark_info")
|
|
2833
|
+
|
|
2834
|
+
@trademark_info.setter
|
|
2835
|
+
def trademark_info(self, value: Optional[pulumi.Input['RegistrationTechnicalContactExtensionFrTrademarkInfoArgs']]):
|
|
2836
|
+
pulumi.set(self, "trademark_info", value)
|
|
2837
|
+
|
|
2838
|
+
|
|
2839
|
+
if not MYPY:
|
|
2840
|
+
class RegistrationTechnicalContactExtensionFrAssociationInfoArgsDict(TypedDict):
|
|
2841
|
+
publication_jo: NotRequired[pulumi.Input[str]]
|
|
2842
|
+
"""
|
|
2843
|
+
Publication date in the Official Journal (RFC3339 format) for association information.
|
|
2844
|
+
"""
|
|
2845
|
+
publication_jo_page: NotRequired[pulumi.Input[int]]
|
|
2846
|
+
"""
|
|
2847
|
+
Page number of the publication in the Official Journal for association information.
|
|
2848
|
+
"""
|
|
2849
|
+
elif False:
|
|
2850
|
+
RegistrationTechnicalContactExtensionFrAssociationInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2851
|
+
|
|
2852
|
+
@pulumi.input_type
|
|
2853
|
+
class RegistrationTechnicalContactExtensionFrAssociationInfoArgs:
|
|
2854
|
+
def __init__(__self__, *,
|
|
2855
|
+
publication_jo: Optional[pulumi.Input[str]] = None,
|
|
2856
|
+
publication_jo_page: Optional[pulumi.Input[int]] = None):
|
|
2857
|
+
"""
|
|
2858
|
+
:param pulumi.Input[str] publication_jo: Publication date in the Official Journal (RFC3339 format) for association information.
|
|
2859
|
+
:param pulumi.Input[int] publication_jo_page: Page number of the publication in the Official Journal for association information.
|
|
2860
|
+
"""
|
|
2861
|
+
if publication_jo is not None:
|
|
2862
|
+
pulumi.set(__self__, "publication_jo", publication_jo)
|
|
2863
|
+
if publication_jo_page is not None:
|
|
2864
|
+
pulumi.set(__self__, "publication_jo_page", publication_jo_page)
|
|
2865
|
+
|
|
2866
|
+
@property
|
|
2867
|
+
@pulumi.getter(name="publicationJo")
|
|
2868
|
+
def publication_jo(self) -> Optional[pulumi.Input[str]]:
|
|
2869
|
+
"""
|
|
2870
|
+
Publication date in the Official Journal (RFC3339 format) for association information.
|
|
2871
|
+
"""
|
|
2872
|
+
return pulumi.get(self, "publication_jo")
|
|
2873
|
+
|
|
2874
|
+
@publication_jo.setter
|
|
2875
|
+
def publication_jo(self, value: Optional[pulumi.Input[str]]):
|
|
2876
|
+
pulumi.set(self, "publication_jo", value)
|
|
2877
|
+
|
|
2878
|
+
@property
|
|
2879
|
+
@pulumi.getter(name="publicationJoPage")
|
|
2880
|
+
def publication_jo_page(self) -> Optional[pulumi.Input[int]]:
|
|
2881
|
+
"""
|
|
2882
|
+
Page number of the publication in the Official Journal for association information.
|
|
2883
|
+
"""
|
|
2884
|
+
return pulumi.get(self, "publication_jo_page")
|
|
2885
|
+
|
|
2886
|
+
@publication_jo_page.setter
|
|
2887
|
+
def publication_jo_page(self, value: Optional[pulumi.Input[int]]):
|
|
2888
|
+
pulumi.set(self, "publication_jo_page", value)
|
|
2889
|
+
|
|
2890
|
+
|
|
2891
|
+
if not MYPY:
|
|
2892
|
+
class RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgsDict(TypedDict):
|
|
2893
|
+
code_auth_afnic: NotRequired[pulumi.Input[str]]
|
|
2894
|
+
"""
|
|
2895
|
+
AFNIC authorization code for the contact (specific to French domains).
|
|
2896
|
+
"""
|
|
2897
|
+
elif False:
|
|
2898
|
+
RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2899
|
+
|
|
2900
|
+
@pulumi.input_type
|
|
2901
|
+
class RegistrationTechnicalContactExtensionFrCodeAuthAfnicInfoArgs:
|
|
2902
|
+
def __init__(__self__, *,
|
|
2903
|
+
code_auth_afnic: Optional[pulumi.Input[str]] = None):
|
|
2904
|
+
"""
|
|
2905
|
+
:param pulumi.Input[str] code_auth_afnic: AFNIC authorization code for the contact (specific to French domains).
|
|
2906
|
+
"""
|
|
2907
|
+
if code_auth_afnic is not None:
|
|
2908
|
+
pulumi.set(__self__, "code_auth_afnic", code_auth_afnic)
|
|
2909
|
+
|
|
2910
|
+
@property
|
|
2911
|
+
@pulumi.getter(name="codeAuthAfnic")
|
|
2912
|
+
def code_auth_afnic(self) -> Optional[pulumi.Input[str]]:
|
|
2913
|
+
"""
|
|
2914
|
+
AFNIC authorization code for the contact (specific to French domains).
|
|
2915
|
+
"""
|
|
2916
|
+
return pulumi.get(self, "code_auth_afnic")
|
|
2917
|
+
|
|
2918
|
+
@code_auth_afnic.setter
|
|
2919
|
+
def code_auth_afnic(self, value: Optional[pulumi.Input[str]]):
|
|
2920
|
+
pulumi.set(self, "code_auth_afnic", value)
|
|
2921
|
+
|
|
2922
|
+
|
|
2923
|
+
if not MYPY:
|
|
2924
|
+
class RegistrationTechnicalContactExtensionFrDunsInfoArgsDict(TypedDict):
|
|
2925
|
+
duns_id: NotRequired[pulumi.Input[str]]
|
|
2926
|
+
"""
|
|
2927
|
+
DUNS ID associated with the domain owner (for French domains).
|
|
2928
|
+
"""
|
|
2929
|
+
local_id: NotRequired[pulumi.Input[str]]
|
|
2930
|
+
"""
|
|
2931
|
+
Local identifier of the domain owner (for French domains).
|
|
2932
|
+
"""
|
|
2933
|
+
elif False:
|
|
2934
|
+
RegistrationTechnicalContactExtensionFrDunsInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2935
|
+
|
|
2936
|
+
@pulumi.input_type
|
|
2937
|
+
class RegistrationTechnicalContactExtensionFrDunsInfoArgs:
|
|
2938
|
+
def __init__(__self__, *,
|
|
2939
|
+
duns_id: Optional[pulumi.Input[str]] = None,
|
|
2940
|
+
local_id: Optional[pulumi.Input[str]] = None):
|
|
2941
|
+
"""
|
|
2942
|
+
:param pulumi.Input[str] duns_id: DUNS ID associated with the domain owner (for French domains).
|
|
2943
|
+
:param pulumi.Input[str] local_id: Local identifier of the domain owner (for French domains).
|
|
2944
|
+
"""
|
|
2945
|
+
if duns_id is not None:
|
|
2946
|
+
pulumi.set(__self__, "duns_id", duns_id)
|
|
2947
|
+
if local_id is not None:
|
|
2948
|
+
pulumi.set(__self__, "local_id", local_id)
|
|
2949
|
+
|
|
2950
|
+
@property
|
|
2951
|
+
@pulumi.getter(name="dunsId")
|
|
2952
|
+
def duns_id(self) -> Optional[pulumi.Input[str]]:
|
|
2953
|
+
"""
|
|
2954
|
+
DUNS ID associated with the domain owner (for French domains).
|
|
2955
|
+
"""
|
|
2956
|
+
return pulumi.get(self, "duns_id")
|
|
2957
|
+
|
|
2958
|
+
@duns_id.setter
|
|
2959
|
+
def duns_id(self, value: Optional[pulumi.Input[str]]):
|
|
2960
|
+
pulumi.set(self, "duns_id", value)
|
|
2961
|
+
|
|
2962
|
+
@property
|
|
2963
|
+
@pulumi.getter(name="localId")
|
|
2964
|
+
def local_id(self) -> Optional[pulumi.Input[str]]:
|
|
2965
|
+
"""
|
|
2966
|
+
Local identifier of the domain owner (for French domains).
|
|
2967
|
+
"""
|
|
2968
|
+
return pulumi.get(self, "local_id")
|
|
2969
|
+
|
|
2970
|
+
@local_id.setter
|
|
2971
|
+
def local_id(self, value: Optional[pulumi.Input[str]]):
|
|
2972
|
+
pulumi.set(self, "local_id", value)
|
|
2973
|
+
|
|
2974
|
+
|
|
2975
|
+
if not MYPY:
|
|
2976
|
+
class RegistrationTechnicalContactExtensionFrIndividualInfoArgsDict(TypedDict):
|
|
2977
|
+
whois_opt_in: NotRequired[pulumi.Input[bool]]
|
|
2978
|
+
"""
|
|
2979
|
+
Whether the individual contact has opted into WHOIS publishing.
|
|
2980
|
+
"""
|
|
2981
|
+
elif False:
|
|
2982
|
+
RegistrationTechnicalContactExtensionFrIndividualInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2983
|
+
|
|
2984
|
+
@pulumi.input_type
|
|
2985
|
+
class RegistrationTechnicalContactExtensionFrIndividualInfoArgs:
|
|
2986
|
+
def __init__(__self__, *,
|
|
2987
|
+
whois_opt_in: Optional[pulumi.Input[bool]] = None):
|
|
2988
|
+
"""
|
|
2989
|
+
:param pulumi.Input[bool] whois_opt_in: Whether the individual contact has opted into WHOIS publishing.
|
|
2990
|
+
"""
|
|
2991
|
+
if whois_opt_in is not None:
|
|
2992
|
+
pulumi.set(__self__, "whois_opt_in", whois_opt_in)
|
|
2993
|
+
|
|
2994
|
+
@property
|
|
2995
|
+
@pulumi.getter(name="whoisOptIn")
|
|
2996
|
+
def whois_opt_in(self) -> Optional[pulumi.Input[bool]]:
|
|
2997
|
+
"""
|
|
2998
|
+
Whether the individual contact has opted into WHOIS publishing.
|
|
2999
|
+
"""
|
|
3000
|
+
return pulumi.get(self, "whois_opt_in")
|
|
3001
|
+
|
|
3002
|
+
@whois_opt_in.setter
|
|
3003
|
+
def whois_opt_in(self, value: Optional[pulumi.Input[bool]]):
|
|
3004
|
+
pulumi.set(self, "whois_opt_in", value)
|
|
3005
|
+
|
|
3006
|
+
|
|
3007
|
+
if not MYPY:
|
|
3008
|
+
class RegistrationTechnicalContactExtensionFrTrademarkInfoArgsDict(TypedDict):
|
|
3009
|
+
trademark_inpi: NotRequired[pulumi.Input[str]]
|
|
3010
|
+
"""
|
|
3011
|
+
Trademark information from INPI (French extension).
|
|
3012
|
+
"""
|
|
3013
|
+
elif False:
|
|
3014
|
+
RegistrationTechnicalContactExtensionFrTrademarkInfoArgsDict: TypeAlias = Mapping[str, Any]
|
|
3015
|
+
|
|
3016
|
+
@pulumi.input_type
|
|
3017
|
+
class RegistrationTechnicalContactExtensionFrTrademarkInfoArgs:
|
|
3018
|
+
def __init__(__self__, *,
|
|
3019
|
+
trademark_inpi: Optional[pulumi.Input[str]] = None):
|
|
3020
|
+
"""
|
|
3021
|
+
:param pulumi.Input[str] trademark_inpi: Trademark information from INPI (French extension).
|
|
3022
|
+
"""
|
|
3023
|
+
if trademark_inpi is not None:
|
|
3024
|
+
pulumi.set(__self__, "trademark_inpi", trademark_inpi)
|
|
3025
|
+
|
|
3026
|
+
@property
|
|
3027
|
+
@pulumi.getter(name="trademarkInpi")
|
|
3028
|
+
def trademark_inpi(self) -> Optional[pulumi.Input[str]]:
|
|
3029
|
+
"""
|
|
3030
|
+
Trademark information from INPI (French extension).
|
|
3031
|
+
"""
|
|
3032
|
+
return pulumi.get(self, "trademark_inpi")
|
|
3033
|
+
|
|
3034
|
+
@trademark_inpi.setter
|
|
3035
|
+
def trademark_inpi(self, value: Optional[pulumi.Input[str]]):
|
|
3036
|
+
pulumi.set(self, "trademark_inpi", value)
|
|
3037
|
+
|
|
3038
|
+
|