godaddy_api 2.0.2

Rust API bindings - sgodaddy_api
Documentation

godaddy_api rust

Authentication

use godaddy_api::Client;

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

cancel

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

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

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

Notes: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)

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

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

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

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

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

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

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

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

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

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

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

Notes: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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Notes: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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Notes: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)

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

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

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()
        },
    });