# godaddy_api rust 

  

 # Authentication 
  
 ```rust
use godaddy_api::Client;

let client = Client::default().with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
```

# cancel

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .cancel(CancelRequest {
        domain: "string".to_string(),
    });
```
# cancel_privacy

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .cancel_privacy(CancelPrivacyRequest {
        domain: "string".to_string(),
    });
```
# record_delete_type_name

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .record_delete_type_name(RecordDeleteTypeNameRequest {
        domain: "string".to_string(),
        type_path: DeleteV1DomainsDomainRecordsTypeNameTypeEnum::A,
        name: "string".to_string(),
    });
```
# domains_forwards_delete
<strong>Notes:</strong><ul><li>**shopperId** is **not the same** as **customerId**.  **shopperId** is a number of max length 10 digits (*ex:* 1234567890) whereas **customerId** is a UUIDv4 (*ex:* 295e3bc3-b3b9-4d95-aae5-ede41a994d13)</li></ul>
```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .domains_forwards_delete(DomainsForwardsDeleteRequest {
        customer_id: "string".to_string(),
        fqdn: "string".to_string(),
    });
```
# delete_v2_customers_customer_id_domains_domain_actions_type

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .delete_v2_customers_customer_id_domains_domain_actions_type(DeleteV2CustomersCustomerIdDomainsDomainActionsTypeRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        type_path: DeleteV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AuthCodePurchase,
    });
```
# delete_v2_customers_customer_id_domains_domain_change_of_registrant

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .delete_v2_customers_customer_id_domains_domain_change_of_registrant(DeleteV2CustomersCustomerIdDomainsDomainChangeOfRegistrantRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# list

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .list(ListRequest {
        ..Default::default()
    });
```
# get_agreement

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_agreement(GetAgreementRequest {
        privacy: true,
        tlds: vec!["string".to_string()],
        ..Default::default()
    });
```
# available

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .available(AvailableRequest {
        domain: "string".to_string(),
        ..Default::default()
    });
```
# schema

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .schema(SchemaRequest {
        tld: "string".to_string(),
    });
```
# suggest

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .suggest(SuggestRequest {
        ..Default::default()
    });
```
# tlds

```rust
use godaddy_api::Client;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client.tlds();
```
# get

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get(GetRequest {
        domain: "string".to_string(),
    });
```
# record_get

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .record_get(RecordGetRequest {
        domain: "string".to_string(),
        type_path: GetV1DomainsDomainRecordsTypeNameTypeEnum::A,
        name: "string".to_string(),
        ..Default::default()
    });
```
# domains_forwards_get
<strong>Notes:</strong><ul><li>**shopperId** is **not the same** as **customerId**.  **shopperId** is a number of max length 10 digits (*ex:* 1234567890) whereas **customerId** is a UUIDv4 (*ex:* 295e3bc3-b3b9-4d95-aae5-ede41a994d13)</li></ul>
```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .domains_forwards_get(DomainsForwardsGetRequest {
        customer_id: "string".to_string(),
        fqdn: "string".to_string(),
        ..Default::default()
    });
```
# get_v2_customers_customer_id_domains_notifications

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_notifications(GetV2CustomersCustomerIdDomainsNotificationsRequest {
        customer_id: "string".to_string(),
    });
```
# get_v2_customers_customer_id_domains_notifications_opt_in

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_notifications_opt_in(GetV2CustomersCustomerIdDomainsNotificationsOptInRequest {
        customer_id: "string".to_string(),
    });
```
# get_v2_customers_customer_id_domains_notifications_schemas_type

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_notifications_schemas_type(GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeRequest {
        customer_id: "string".to_string(),
        type_path: GetV2CustomersCustomerIdDomainsNotificationsSchemasTypeTypeEnum::AutoRenewal,
    });
```
# get_v2_customers_customer_id_domains_register_schema_tld

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_register_schema_tld(GetV2CustomersCustomerIdDomainsRegisterSchemaTldRequest {
        customer_id: "string".to_string(),
        tld: "string".to_string(),
    });
```
# get_v2_customers_customer_id_domains_domain

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_domain(GetV2CustomersCustomerIdDomainsDomainRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        ..Default::default()
    });
```
# get_v2_customers_customer_id_domains_domain_actions

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_domain_actions(GetV2CustomersCustomerIdDomainsDomainActionsRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# get_v2_customers_customer_id_domains_domain_actions_type

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_domain_actions_type(GetV2CustomersCustomerIdDomainsDomainActionsTypeRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        type_path: GetV2CustomersCustomerIdDomainsDomainActionsTypeTypeEnum::AuthCodePurchase,
    });
```
# get_v2_customers_customer_id_domains_domain_change_of_registrant

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_domain_change_of_registrant(GetV2CustomersCustomerIdDomainsDomainChangeOfRegistrantRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# get_v2_customers_customer_id_domains_domain_privacy_forwarding

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_customers_customer_id_domains_domain_privacy_forwarding(GetV2CustomersCustomerIdDomainsDomainPrivacyForwardingRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# get_v2_domains_maintenances

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_domains_maintenances(GetV2DomainsMaintenancesRequest {
        ..Default::default()
    });
```
# get_v2_domains_maintenances_maintenance_id

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .get_v2_domains_maintenances_maintenance_id(GetV2DomainsMaintenancesMaintenanceIdRequest {
        maintenance_id: "string".to_string(),
    });
```
# update

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .update(UpdateRequest {
        domain: "string".to_string(),
        data: DomainUpdate {
            ..Default::default()
        },
    });
```
# update_contacts

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .update_contacts(UpdateContactsRequest {
        domain: "string".to_string(),
        data: DomainContacts {
            contact_registrant: Contact {
                address_mailing: Address {
                    address1: "string".to_string(),
                    city: "string".to_string(),
                    country: AddressCountryEnum::Ac,
                    postal_code: "string".to_string(),
                    state: "string".to_string(),
                    ..Default::default()
                },
                email: "mail@example.com".to_string(),
                name_first: "string".to_string(),
                name_last: "string".to_string(),
                phone: "string".to_string(),
                ..Default::default()
            },
            ..Default::default()
        },
    });
```
# record_add

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .record_add(RecordAddRequest {
        domain: "string".to_string(),
        data: vec![
            DnsRecord { data : "string".to_string(), name : "string".to_string(),
            type_field : DnsRecordTypeEnum::A, ..Default::default() }
        ],
    });
```
# patch_v2_customers_customer_id_domains_domain_privacy_forwarding

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .patch_v2_customers_customer_id_domains_domain_privacy_forwarding(PatchV2CustomersCustomerIdDomainsDomainPrivacyForwardingRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainPrivacyForwardingUpdate {
            email_preference: DomainPrivacyForwardingUpdateEmailPreferenceEnum::EmailFilter,
            private_email_type: DomainPrivacyForwardingUpdatePrivateEmailTypeEnum::Default,
            ..Default::default()
        },
    });
```
# available_bulk

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .available_bulk(AvailableBulkRequest {
        data: vec!["string".to_string()],
        ..Default::default()
    });
```
# contacts_validate
All contacts specified in request will be validated against all domains specifed in "domains". As an alternative, you can also pass in tlds, with the exception of `uk`, which requires full domain names
```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .contacts_validate(ContactsValidateRequest {
        data: DomainsContactsBulk {
            domains: vec!["string".to_string()],
            ..Default::default()
        },
        ..Default::default()
    });
```
# purchase

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .purchase(PurchaseRequest {
        data: DomainPurchase {
            consent: Consent {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
            },
            domain: "string".to_string(),
            ..Default::default()
        },
    });
```
# validate

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .validate(ValidateRequest {
        data: DomainPurchase {
            consent: Consent {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
            },
            domain: "string".to_string(),
            ..Default::default()
        },
    });
```
# purchase_privacy

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .purchase_privacy(PurchasePrivacyRequest {
        domain: "string".to_string(),
        data: PrivacyPurchase {
            consent: Consent {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
            },
        },
    });
```
# renew

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .renew(RenewRequest {
        domain: "string".to_string(),
        data: DomainRenew {
            ..Default::default()
        },
    });
```
# transfer_in

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .transfer_in(TransferInRequest {
        domain: "string".to_string(),
        data: DomainTransferIn {
            auth_code: "string".to_string(),
            consent: Consent {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
            },
            ..Default::default()
        },
    });
```
# verify_email

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .verify_email(VerifyEmailRequest {
        domain: "string".to_string(),
    });
```
# domains_forwards_post
<strong>Notes:</strong><ul><li>**shopperId** is **not the same** as **customerId**.  **shopperId** is a number of max length 10 digits (*ex:* 1234567890) whereas **customerId** is a UUIDv4 (*ex:* 295e3bc3-b3b9-4d95-aae5-ede41a994d13)</li></ul>
```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .domains_forwards_post(DomainsForwardsPostRequest {
        customer_id: "string".to_string(),
        fqdn: "string".to_string(),
        data: DomainForwardingCreate {
            type_field: DomainForwardingCreateTypeEnum::Masked,
            url: "http://www.example.com".to_string(),
            ..Default::default()
        },
    });
```
# post_v2_customers_customer_id_domains_notifications_notification_id_acknowledge

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_notifications_notification_id_acknowledge(PostV2CustomersCustomerIdDomainsNotificationsNotificationIdAcknowledgeRequest {
        customer_id: "string".to_string(),
        notification_id: "string".to_string(),
    });
```
# post_v2_customers_customer_id_domains_register

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_register(PostV2CustomersCustomerIdDomainsRegisterRequest {
        customer_id: "string".to_string(),
        data: DomainPurchaseV2 {
            consent: ConsentV2 {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
                currency: "string".to_string(),
                price: 123,
                ..Default::default()
            },
            domain: "string".to_string(),
            ..Default::default()
        },
    });
```
# post_v2_customers_customer_id_domains_register_validate

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_register_validate(PostV2CustomersCustomerIdDomainsRegisterValidateRequest {
        customer_id: "string".to_string(),
        data: DomainPurchaseV2 {
            consent: ConsentV2 {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
                currency: "string".to_string(),
                price: 123,
                ..Default::default()
            },
            domain: "string".to_string(),
            ..Default::default()
        },
    });
```
# post_v2_customers_customer_id_domains_domain_redeem

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_redeem(PostV2CustomersCustomerIdDomainsDomainRedeemRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainRedeemV2 {
            consent: ConsentRedemption {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                currency: "string".to_string(),
                fee: 123,
                price: 123,
            },
        },
    });
```
# post_v2_customers_customer_id_domains_domain_renew

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_renew(PostV2CustomersCustomerIdDomainsDomainRenewRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainRenewV2 {
            consent: ConsentRenew {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                currency: "string".to_string(),
                price: 123,
                ..Default::default()
            },
            expires: "string".to_string(),
            ..Default::default()
        },
    });
```
# post_v2_customers_customer_id_domains_domain_transfer

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer(PostV2CustomersCustomerIdDomainsDomainTransferRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainTransferInV2 {
            auth_code: "string".to_string(),
            consent: ConsentV2 {
                agreed_at: "string".to_string(),
                agreed_by: "string".to_string(),
                agreement_keys: vec!["string".to_string()],
                currency: "string".to_string(),
                price: 123,
                ..Default::default()
            },
            ..Default::default()
        },
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_in_accept

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_in_accept(PostV2CustomersCustomerIdDomainsDomainTransferInAcceptRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainTransferAuthCode {
            auth_code: "string".to_string(),
        },
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_in_cancel

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_in_cancel(PostV2CustomersCustomerIdDomainsDomainTransferInCancelRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_in_restart

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_in_restart(PostV2CustomersCustomerIdDomainsDomainTransferInRestartRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_in_retry

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_in_retry(PostV2CustomersCustomerIdDomainsDomainTransferInRetryRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainTransferAuthCode {
            auth_code: "string".to_string(),
        },
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_out

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_out(PostV2CustomersCustomerIdDomainsDomainTransferOutRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        registrar: "string".to_string(),
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_out_accept

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_out_accept(PostV2CustomersCustomerIdDomainsDomainTransferOutAcceptRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
    });
```
# post_v2_customers_customer_id_domains_domain_transfer_out_reject

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .post_v2_customers_customer_id_domains_domain_transfer_out_reject(PostV2CustomersCustomerIdDomainsDomainTransferOutRejectRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        ..Default::default()
    });
```
# record_replace

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .record_replace(RecordReplaceRequest {
        domain: "string".to_string(),
        data: vec![
            DnsRecord { data : "string".to_string(), name : "string".to_string(),
            type_field : DnsRecordTypeEnum::A, ..Default::default() }
        ],
    });
```
# record_replace_type

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .record_replace_type(RecordReplaceTypeRequest {
        domain: "string".to_string(),
        type_path: PutV1DomainsDomainRecordsTypeTypeEnum::A,
        data: vec![
            DnsRecordCreateType { data : "string".to_string(), name : "string"
            .to_string(), ..Default::default() }
        ],
    });
```
# record_replace_type_name

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .record_replace_type_name(RecordReplaceTypeNameRequest {
        domain: "string".to_string(),
        type_path: PutV1DomainsDomainRecordsTypeNameTypeEnum::A,
        name: "string".to_string(),
        data: vec![
            DnsRecordCreateTypeName { data : "string".to_string(),
            ..Default::default() }
        ],
    });
```
# domains_forwards_put
<strong>Notes:</strong><ul><li>**shopperId** is **not the same** as **customerId**.  **shopperId** is a number of max length 10 digits (*ex:* 1234567890) whereas **customerId** is a UUIDv4 (*ex:* 295e3bc3-b3b9-4d95-aae5-ede41a994d13)</li></ul>
```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .domains_forwards_put(DomainsForwardsPutRequest {
        customer_id: "string".to_string(),
        fqdn: "string".to_string(),
        data: DomainForwardingCreate {
            type_field: DomainForwardingCreateTypeEnum::Masked,
            url: "http://www.example.com".to_string(),
            ..Default::default()
        },
    });
```
# put_v2_customers_customer_id_domains_notifications_opt_in

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .put_v2_customers_customer_id_domains_notifications_opt_in(PutV2CustomersCustomerIdDomainsNotificationsOptInRequest {
        customer_id: "string".to_string(),
        types: vec![
            PutV2CustomersCustomerIdDomainsNotificationsOptInTypesItemEnum::AuthCodePurchase
        ],
    });
```
# put_v2_customers_customer_id_domains_domain_name_servers

```rust
use godaddy_api::Client;
use godaddy_api::request_types::*;
use godaddy_api::schemas::*;
let client = Client::default()
    .with_api_key_auth(&std::env::var("API_KEY").expect("API key not defined"));
let response = client
    .put_v2_customers_customer_id_domains_domain_name_servers(PutV2CustomersCustomerIdDomainsDomainNameServersRequest {
        customer_id: "string".to_string(),
        domain: "string".to_string(),
        data: DomainNameServerUpdateV2 {
            ..Default::default()
        },
    });
```