import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const ns = T.XmlNamespace("https://route53domains.amazonaws.com/doc/2014-05-15/");
const svc = T.AwsApiService({
    sdkId: "Route 53 Domains",
    serviceShapeName: "Route53Domains_v20140515",
});
const auth = T.AwsAuthSigv4({ name: "route53domains" });
const ver = T.ServiceVersion("2014-05-15");
const proto = T.AwsProtocolsAwsJson1_1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://route53domains-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://route53domains-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://route53domains.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://route53domains.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const AcceptDomainTransferFromAnotherAwsAccountRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, Password: SensitiveString }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "AcceptDomainTransferFromAnotherAwsAccountRequest",
});
export const AcceptDomainTransferFromAnotherAwsAccountResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "AcceptDomainTransferFromAnotherAwsAccountResponse",
});
export const DnssecSigningAttributes = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Algorithm: S.optional(S.Number),
    Flags: S.optional(S.Number),
    PublicKey: S.optional(S.String),
})).annotate({
    identifier: "DnssecSigningAttributes",
});
export const AssociateDelegationSignerToDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    SigningAttributes: DnssecSigningAttributes,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "AssociateDelegationSignerToDomainRequest",
});
export const AssociateDelegationSignerToDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "AssociateDelegationSignerToDomainResponse",
});
export const CancelDomainTransferToAnotherAwsAccountRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelDomainTransferToAnotherAwsAccountRequest",
});
export const CancelDomainTransferToAnotherAwsAccountResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "CancelDomainTransferToAnotherAwsAccountResponse",
});
export const CheckDomainAvailabilityRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, IdnLangCode: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CheckDomainAvailabilityRequest",
});
export const DomainAvailability = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CheckDomainAvailabilityResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Availability: S.optional(DomainAvailability) }).pipe(ns)).annotate({
    identifier: "CheckDomainAvailabilityResponse",
});
export const CheckDomainTransferabilityRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    AuthCode: S.optional(SensitiveString),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CheckDomainTransferabilityRequest",
});
export const Transferable = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DomainTransferability = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Transferable: S.optional(Transferable) })).annotate({
    identifier: "DomainTransferability",
});
export const CheckDomainTransferabilityResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Transferability: S.optional(DomainTransferability),
    Message: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "CheckDomainTransferabilityResponse",
});
export const DeleteDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteDomainRequest",
});
export const DeleteDomainResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "DeleteDomainResponse",
});
export const TagKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DeleteTagsForDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, TagsToDelete: TagKeyList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteTagsForDomainRequest",
});
export const DeleteTagsForDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeleteTagsForDomainResponse",
});
export const DisableDomainAutoRenewRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DisableDomainAutoRenewRequest",
});
export const DisableDomainAutoRenewResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DisableDomainAutoRenewResponse",
});
export const DisableDomainTransferLockRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DisableDomainTransferLockRequest",
});
export const DisableDomainTransferLockResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "DisableDomainTransferLockResponse",
});
export const DisassociateDelegationSignerFromDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, Id: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DisassociateDelegationSignerFromDomainRequest",
});
export const DisassociateDelegationSignerFromDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "DisassociateDelegationSignerFromDomainResponse",
});
export const EnableDomainAutoRenewRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "EnableDomainAutoRenewRequest",
});
export const EnableDomainAutoRenewResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "EnableDomainAutoRenewResponse",
});
export const EnableDomainTransferLockRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "EnableDomainTransferLockRequest",
});
export const EnableDomainTransferLockResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "EnableDomainTransferLockResponse",
});
export const GetContactReachabilityStatusRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ domainName: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetContactReachabilityStatusRequest",
});
export const ReachabilityStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const GetContactReachabilityStatusResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    domainName: S.optional(S.String),
    status: S.optional(ReachabilityStatus),
}).pipe(ns)).annotate({
    identifier: "GetContactReachabilityStatusResponse",
});
export const GetDomainDetailRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDomainDetailRequest",
});
export const GlueIpList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Nameserver = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, GlueIps: S.optional(GlueIpList) })).annotate({ identifier: "Nameserver" });
export const NameserverList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Nameserver);
export const ContactType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CountryCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExtraParamName = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExtraParam = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: ExtraParamName, Value: SensitiveString })).annotate({ identifier: "ExtraParam" });
export const ExtraParamList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ExtraParam);
export const ContactDetail = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FirstName: S.optional(SensitiveString),
    LastName: S.optional(SensitiveString),
    ContactType: S.optional(ContactType),
    OrganizationName: S.optional(SensitiveString),
    AddressLine1: S.optional(SensitiveString),
    AddressLine2: S.optional(SensitiveString),
    City: S.optional(SensitiveString),
    State: S.optional(SensitiveString),
    CountryCode: S.optional(CountryCode),
    ZipCode: S.optional(SensitiveString),
    PhoneNumber: S.optional(SensitiveString),
    Email: S.optional(SensitiveString),
    Fax: S.optional(SensitiveString),
    ExtraParams: S.optional(ExtraParamList),
})).annotate({ identifier: "ContactDetail" });
export const DomainStatusList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DnssecKey = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Algorithm: S.optional(S.Number),
    Flags: S.optional(S.Number),
    PublicKey: S.optional(S.String),
    DigestType: S.optional(S.Number),
    Digest: S.optional(S.String),
    KeyTag: S.optional(S.Number),
    Id: S.optional(S.String),
})).annotate({ identifier: "DnssecKey" });
export const DnssecKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(DnssecKey);
export const GetDomainDetailResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String),
    Nameservers: S.optional(NameserverList),
    AutoRenew: S.optional(S.Boolean),
    AdminContact: S.optional(ContactDetail),
    RegistrantContact: S.optional(ContactDetail),
    TechContact: S.optional(ContactDetail),
    AdminPrivacy: S.optional(S.Boolean),
    RegistrantPrivacy: S.optional(S.Boolean),
    TechPrivacy: S.optional(S.Boolean),
    RegistrarName: S.optional(S.String),
    WhoIsServer: S.optional(S.String),
    RegistrarUrl: S.optional(S.String),
    AbuseContactEmail: S.optional(SensitiveString),
    AbuseContactPhone: S.optional(SensitiveString),
    RegistryDomainId: S.optional(S.String),
    CreationDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    UpdatedDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ExpirationDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Reseller: S.optional(S.String),
    DnsSec: S.optional(S.String),
    StatusList: S.optional(DomainStatusList),
    DnssecKeys: S.optional(DnssecKeyList),
    BillingContact: S.optional(ContactDetail),
    BillingPrivacy: S.optional(S.Boolean),
}).pipe(ns)).annotate({
    identifier: "GetDomainDetailResponse",
});
export const GetDomainSuggestionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    SuggestionCount: S.Number,
    OnlyAvailable: S.Boolean,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDomainSuggestionsRequest",
});
export const DomainSuggestion = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String),
    Availability: S.optional(S.String),
})).annotate({
    identifier: "DomainSuggestion",
});
export const DomainSuggestionsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DomainSuggestion);
export const GetDomainSuggestionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SuggestionsList: S.optional(DomainSuggestionsList) }).pipe(ns)).annotate({
    identifier: "GetDomainSuggestionsResponse",
});
export const GetOperationDetailRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetOperationDetailRequest",
});
export const OperationStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const OperationType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const StatusFlag = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const GetOperationDetailResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    OperationId: S.optional(S.String),
    Status: S.optional(OperationStatus),
    Message: S.optional(S.String),
    DomainName: S.optional(S.String),
    Type: S.optional(OperationType),
    SubmittedDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastUpdatedDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    StatusFlag: S.optional(StatusFlag),
}).pipe(ns)).annotate({
    identifier: "GetOperationDetailResponse",
});
export const ListDomainsAttributeName = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Operator = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Values = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const FilterCondition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: ListDomainsAttributeName,
    Operator: Operator,
    Values: Values,
})).annotate({
    identifier: "FilterCondition",
});
export const FilterConditions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(FilterCondition);
export const SortOrder = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const SortCondition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: ListDomainsAttributeName, SortOrder: SortOrder })).annotate({ identifier: "SortCondition" });
export const ListDomainsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FilterConditions: S.optional(FilterConditions),
    SortCondition: S.optional(SortCondition),
    Marker: S.optional(S.String),
    MaxItems: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDomainsRequest",
});
export const DomainSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String),
    AutoRenew: S.optional(S.Boolean),
    TransferLock: S.optional(S.Boolean),
    Expiry: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "DomainSummary" });
export const DomainSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DomainSummary);
export const ListDomainsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Domains: S.optional(DomainSummaryList),
    NextPageMarker: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListDomainsResponse",
});
export const OperationStatusList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(OperationStatus);
export const OperationTypeList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(OperationType);
export const ListOperationsSortAttributeName = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const ListOperationsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SubmittedSince: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Marker: S.optional(S.String),
    MaxItems: S.optional(S.Number),
    Status: S.optional(OperationStatusList),
    Type: S.optional(OperationTypeList),
    SortBy: S.optional(ListOperationsSortAttributeName),
    SortOrder: S.optional(SortOrder),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListOperationsRequest",
});
export const OperationSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    OperationId: S.optional(S.String),
    Status: S.optional(OperationStatus),
    Type: S.optional(OperationType),
    SubmittedDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    DomainName: S.optional(S.String),
    Message: S.optional(S.String),
    StatusFlag: S.optional(StatusFlag),
    LastUpdatedDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "OperationSummary",
});
export const OperationSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(OperationSummary);
export const ListOperationsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Operations: S.optional(OperationSummaryList),
    NextPageMarker: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListOperationsResponse",
});
export const ListPricesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Tld: S.optional(S.String),
    Marker: S.optional(S.String),
    MaxItems: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPricesRequest",
});
export const PriceWithCurrency = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Price: S.Number, Currency: S.String })).annotate({
    identifier: "PriceWithCurrency",
});
export const DomainPrice = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    RegistrationPrice: S.optional(PriceWithCurrency),
    TransferPrice: S.optional(PriceWithCurrency),
    RenewalPrice: S.optional(PriceWithCurrency),
    ChangeOwnershipPrice: S.optional(PriceWithCurrency),
    RestorationPrice: S.optional(PriceWithCurrency),
})).annotate({ identifier: "DomainPrice" });
export const DomainPriceList = /*@__PURE__*/ /*#__PURE__*/ S.Array(DomainPrice);
export const ListPricesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Prices: S.optional(DomainPriceList),
    NextPageMarker: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListPricesResponse",
});
export const ListTagsForDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForDomainRequest",
});
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.optional(S.String), Value: S.optional(S.String) })).annotate({ identifier: "Tag" });
export const TagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag);
export const ListTagsForDomainResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TagList: S.optional(TagList) }).pipe(ns)).annotate({
    identifier: "ListTagsForDomainResponse",
});
export const PushDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, Target: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PushDomainRequest",
});
export const PushDomainResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "PushDomainResponse",
});
export const RegisterDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    IdnLangCode: S.optional(S.String),
    DurationInYears: S.Number,
    AutoRenew: S.optional(S.Boolean),
    AdminContact: ContactDetail,
    RegistrantContact: ContactDetail,
    TechContact: ContactDetail,
    PrivacyProtectAdminContact: S.optional(S.Boolean),
    PrivacyProtectRegistrantContact: S.optional(S.Boolean),
    PrivacyProtectTechContact: S.optional(S.Boolean),
    BillingContact: S.optional(ContactDetail),
    PrivacyProtectBillingContact: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RegisterDomainRequest",
});
export const RegisterDomainResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "RegisterDomainResponse",
});
export const RejectDomainTransferFromAnotherAwsAccountRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RejectDomainTransferFromAnotherAwsAccountRequest",
});
export const RejectDomainTransferFromAnotherAwsAccountResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "RejectDomainTransferFromAnotherAwsAccountResponse",
});
export const RenewDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    DurationInYears: S.optional(S.Number),
    CurrentExpiryYear: S.Number,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RenewDomainRequest",
});
export const RenewDomainResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "RenewDomainResponse",
});
export const ResendContactReachabilityEmailRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ domainName: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ResendContactReachabilityEmailRequest",
});
export const ResendContactReachabilityEmailResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    domainName: S.optional(S.String),
    emailAddress: S.optional(SensitiveString),
    isAlreadyVerified: S.optional(S.Boolean),
}).pipe(ns)).annotate({
    identifier: "ResendContactReachabilityEmailResponse",
});
export const ResendOperationAuthorizationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ResendOperationAuthorizationRequest",
});
export const ResendOperationAuthorizationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "ResendOperationAuthorizationResponse",
});
export const RetrieveDomainAuthCodeRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RetrieveDomainAuthCodeRequest",
});
export const RetrieveDomainAuthCodeResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AuthCode: S.optional(SensitiveString) }).pipe(ns)).annotate({
    identifier: "RetrieveDomainAuthCodeResponse",
});
export const TransferDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    IdnLangCode: S.optional(S.String),
    DurationInYears: S.Number,
    Nameservers: S.optional(NameserverList),
    AuthCode: S.optional(SensitiveString),
    AutoRenew: S.optional(S.Boolean),
    AdminContact: ContactDetail,
    RegistrantContact: ContactDetail,
    TechContact: ContactDetail,
    PrivacyProtectAdminContact: S.optional(S.Boolean),
    PrivacyProtectRegistrantContact: S.optional(S.Boolean),
    PrivacyProtectTechContact: S.optional(S.Boolean),
    BillingContact: S.optional(ContactDetail),
    PrivacyProtectBillingContact: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TransferDomainRequest",
});
export const TransferDomainResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "TransferDomainResponse",
});
export const TransferDomainToAnotherAwsAccountRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, AccountId: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TransferDomainToAnotherAwsAccountRequest",
});
export const TransferDomainToAnotherAwsAccountResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    OperationId: S.optional(S.String),
    Password: S.optional(SensitiveString),
}).pipe(ns)).annotate({
    identifier: "TransferDomainToAnotherAwsAccountResponse",
});
export const Consent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MaxPrice: S.Number, Currency: S.String })).annotate({ identifier: "Consent" });
export const UpdateDomainContactRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    AdminContact: S.optional(ContactDetail),
    RegistrantContact: S.optional(ContactDetail),
    TechContact: S.optional(ContactDetail),
    Consent: S.optional(Consent),
    BillingContact: S.optional(ContactDetail),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateDomainContactRequest",
});
export const UpdateDomainContactResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "UpdateDomainContactResponse",
});
export const UpdateDomainContactPrivacyRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    AdminPrivacy: S.optional(S.Boolean),
    RegistrantPrivacy: S.optional(S.Boolean),
    TechPrivacy: S.optional(S.Boolean),
    BillingPrivacy: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateDomainContactPrivacyRequest",
});
export const UpdateDomainContactPrivacyResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "UpdateDomainContactPrivacyResponse",
});
export const UpdateDomainNameserversRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    FIAuthKey: S.optional(SensitiveString),
    Nameservers: NameserverList,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateDomainNameserversRequest",
});
export const UpdateDomainNameserversResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OperationId: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "UpdateDomainNameserversResponse",
});
export const UpdateTagsForDomainRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String, TagsToUpdate: S.optional(TagList) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateTagsForDomainRequest",
});
export const UpdateTagsForDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "UpdateTagsForDomainResponse",
});
export const ViewBillingRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Start: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    End: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Marker: S.optional(S.String),
    MaxItems: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ViewBillingRequest",
});
export const BillingRecord = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String),
    Operation: S.optional(OperationType),
    InvoiceId: S.optional(S.String),
    BillDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Price: S.optional(S.Number),
})).annotate({ identifier: "BillingRecord" });
export const BillingRecords = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BillingRecord);
export const ViewBillingResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextPageMarker: S.optional(S.String),
    BillingRecords: S.optional(BillingRecords),
}).pipe(ns)).annotate({
    identifier: "ViewBillingResponse",
});
//# Errors
export class DomainLimitExceeded extends S.TaggedErrorClass()("DomainLimitExceeded", { message: S.optional(S.String) }).pipe(C.withBadRequestError, C.withThrottlingError) {
}
export class InvalidInput extends S.TaggedErrorClass()("InvalidInput", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class OperationLimitExceeded extends S.TaggedErrorClass()("OperationLimitExceeded", { message: S.optional(S.String) }).pipe(C.withBadRequestError, C.withThrottlingError) {
}
export class UnsupportedTLD extends S.TaggedErrorClass()("UnsupportedTLD", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class DnssecLimitExceeded extends S.TaggedErrorClass()("DnssecLimitExceeded", { message: S.optional(S.String) }).pipe(C.withBadRequestError, C.withThrottlingError) {
}
export class DuplicateRequest extends S.TaggedErrorClass()("DuplicateRequest", { requestId: S.optional(S.String), message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class TLDRulesViolation extends S.TaggedErrorClass()("TLDRulesViolation", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
/**
 * Accepts the transfer of a domain from another Amazon Web Services account to the
 * currentAmazon Web Services account. You initiate a transfer between Amazon Web Services accounts using TransferDomainToAnotherAwsAccount.
 *
 * If you use the CLI command at accept-domain-transfer-from-another-aws-account, use JSON format as input
 * instead of text because otherwise CLI will throw an error from domain
 * transfer input that includes single quotes.
 *
 * Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
 * `Domain Transfer from Aws Account 111122223333 has been cancelled`.
 */
export const acceptDomainTransferFromAnotherAwsAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AcceptDomainTransferFromAnotherAwsAccountRequest,
    output: AcceptDomainTransferFromAnotherAwsAccountResponse,
    errors: [
        DomainLimitExceeded,
        InvalidInput,
        OperationLimitExceeded,
        UnsupportedTLD,
    ],
}));
/**
 * Creates a delegation signer (DS) record in the registry zone for this domain
 * name.
 *
 * Note that creating DS record at the registry impacts DNSSEC validation of your DNS
 * records. This action may render your domain name unavailable on the internet if the
 * steps are completed in the wrong order, or with incorrect timing. For more information
 * about DNSSEC signing, see Configuring DNSSEC
 * signing in the Route 53 developer
 * guide.
 */
export const associateDelegationSignerToDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AssociateDelegationSignerToDomainRequest,
    output: AssociateDelegationSignerToDomainResponse,
    errors: [
        DnssecLimitExceeded,
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * Cancels the transfer of a domain from the current Amazon Web Services account to
 * another Amazon Web Services account. You initiate a transfer betweenAmazon Web Services accounts using TransferDomainToAnotherAwsAccount.
 *
 * You must cancel the transfer before the other Amazon Web Services account accepts
 * the transfer using AcceptDomainTransferFromAnotherAwsAccount.
 *
 * Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
 * `Domain Transfer from Aws Account 111122223333 has been cancelled`.
 */
export const cancelDomainTransferToAnotherAwsAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelDomainTransferToAnotherAwsAccountRequest,
    output: CancelDomainTransferToAnotherAwsAccountResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * This operation checks the availability of one domain name. Note that if the
 * availability status of a domain is pending, you must submit another request to determine
 * the availability of the domain name.
 */
export const checkDomainAvailability = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CheckDomainAvailabilityRequest,
    output: CheckDomainAvailabilityResponse,
    errors: [InvalidInput, UnsupportedTLD],
}));
/**
 * Checks whether a domain name can be transferred to Amazon Route 53.
 */
export const checkDomainTransferability = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CheckDomainTransferabilityRequest,
    output: CheckDomainTransferabilityResponse,
    errors: [InvalidInput, UnsupportedTLD],
}));
/**
 * This operation deletes the specified domain. This action is permanent. For more
 * information, see Deleting a domain name
 * registration.
 *
 * To transfer the domain registration to another registrar, use the transfer process
 * that’s provided by the registrar to which you want to transfer the registration.
 * Otherwise, the following apply:
 *
 * - You can’t get a refund for the cost of a deleted domain registration.
 *
 * - The registry for the top-level domain might hold the domain name for a brief
 * time before releasing it for other users to register (varies by registry).
 *
 * - When the registration has been deleted, we'll send you a confirmation to the
 * registrant contact. The email will come from
 * `noreply@domainnameverification.net` or
 * `noreply@registrar.amazon.com`.
 */
export const deleteDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteDomainRequest,
    output: DeleteDomainResponse,
    errors: [DuplicateRequest, InvalidInput, TLDRulesViolation, UnsupportedTLD],
}));
/**
 * This operation deletes the specified tags for a domain.
 *
 * All tag operations are eventually consistent; subsequent operations might not
 * immediately represent all issued operations.
 */
export const deleteTagsForDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteTagsForDomainRequest,
    output: DeleteTagsForDomainResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * This operation disables automatic renewal of domain registration for the specified
 * domain.
 */
export const disableDomainAutoRenew = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DisableDomainAutoRenewRequest,
    output: DisableDomainAutoRenewResponse,
    errors: [InvalidInput, UnsupportedTLD],
}));
/**
 * This operation removes the transfer lock on the domain (specifically the
 * `clientTransferProhibited` status) to allow domain transfers. We
 * recommend you refrain from performing this action unless you intend to transfer the
 * domain to a different registrar. Successful submission returns an operation ID that you
 * can use to track the progress and completion of the action. If the request is not
 * completed successfully, the domain registrant will be notified by email.
 */
export const disableDomainTransferLock = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DisableDomainTransferLockRequest,
    output: DisableDomainTransferLockResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * Deletes a delegation signer (DS) record in the registry zone for this domain
 * name.
 */
export const disassociateDelegationSignerFromDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DisassociateDelegationSignerFromDomainRequest,
    output: DisassociateDelegationSignerFromDomainResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * This operation configures Amazon Route 53 to automatically renew the specified domain
 * before the domain registration expires. The cost of renewing your domain registration is
 * billed to your Amazon Web Services account.
 *
 * The period during which you can renew a domain name varies by TLD. For a list of TLDs
 * and their renewal policies, see Domains That You Can
 * Register with Amazon Route 53 in the Amazon Route 53 Developer
 * Guide. Route 53 requires that you renew before the end of the renewal
 * period so we can complete processing before the deadline.
 */
export const enableDomainAutoRenew = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: EnableDomainAutoRenewRequest,
    output: EnableDomainAutoRenewResponse,
    errors: [InvalidInput, TLDRulesViolation, UnsupportedTLD],
}));
/**
 * This operation sets the transfer lock on the domain (specifically the
 * `clientTransferProhibited` status) to prevent domain transfers.
 * Successful submission returns an operation ID that you can use to track the progress and
 * completion of the action. If the request is not completed successfully, the domain
 * registrant will be notified by email.
 */
export const enableDomainTransferLock = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: EnableDomainTransferLockRequest,
    output: EnableDomainTransferLockResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * For operations that require confirmation that the email address for the registrant
 * contact is valid, such as registering a new domain, this operation returns information
 * about whether the registrant contact has responded.
 *
 * If you want us to resend the email, use the
 * `ResendContactReachabilityEmail` operation.
 */
export const getContactReachabilityStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetContactReachabilityStatusRequest,
    output: GetContactReachabilityStatusResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * This operation returns detailed information about a specified domain that is
 * associated with the current Amazon Web Services account. Contact information for the
 * domain is also returned as part of the output.
 */
export const getDomainDetail = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDomainDetailRequest,
    output: GetDomainDetailResponse,
    errors: [InvalidInput, UnsupportedTLD],
}));
/**
 * The GetDomainSuggestions operation returns a list of suggested domain names.
 */
export const getDomainSuggestions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDomainSuggestionsRequest,
    output: GetDomainSuggestionsResponse,
    errors: [InvalidInput, UnsupportedTLD],
}));
/**
 * This operation returns the current status of an operation that is not
 * completed.
 */
export const getOperationDetail = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetOperationDetailRequest,
    output: GetOperationDetailResponse,
    errors: [InvalidInput],
}));
/**
 * This operation returns all the domain names registered with Amazon Route 53 for the
 * current Amazon Web Services account if no filtering conditions are used.
 */
export const listDomains = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListDomainsRequest,
    output: ListDomainsResponse,
    errors: [InvalidInput],
    pagination: {
        inputToken: "Marker",
        outputToken: "NextPageMarker",
        items: "Domains",
        pageSize: "MaxItems",
    },
}));
/**
 * Returns information about all of the operations that return an operation ID and that
 * have ever been performed on domains that were registered by the current account.
 *
 * This command runs only in the us-east-1 Region.
 */
export const listOperations = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListOperationsRequest,
    output: ListOperationsResponse,
    errors: [InvalidInput],
    pagination: {
        inputToken: "Marker",
        outputToken: "NextPageMarker",
        items: "Operations",
        pageSize: "MaxItems",
    },
}));
/**
 * Lists the following prices for either all the TLDs supported by Route 53, or
 * the specified TLD:
 *
 * - Registration
 *
 * - Transfer
 *
 * - Owner change
 *
 * - Domain renewal
 *
 * - Domain restoration
 */
export const listPrices = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPricesRequest,
    output: ListPricesResponse,
    errors: [InvalidInput, UnsupportedTLD],
    pagination: {
        inputToken: "Marker",
        outputToken: "NextPageMarker",
        items: "Prices",
        pageSize: "MaxItems",
    },
}));
/**
 * This operation returns all of the tags that are associated with the specified
 * domain.
 *
 * All tag operations are eventually consistent; subsequent operations might not
 * immediately represent all issued operations.
 */
export const listTagsForDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForDomainRequest,
    output: ListTagsForDomainResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * Moves a domain from Amazon Web Services to another registrar.
 *
 * Supported actions:
 *
 * - Changes the IPS tags of a .uk domain, and pushes it to transit. Transit means
 * that the domain is ready to be transferred to another registrar.
 */
export const pushDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PushDomainRequest,
    output: PushDomainResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * This operation registers a domain. For some top-level domains (TLDs), this operation
 * requires extra parameters.
 *
 * When you register a domain, Amazon Route 53 does the following:
 *
 * - Creates a Route 53 hosted zone that has the same name as the domain. Route 53
 * assigns four name servers to your hosted zone and automatically updates your
 * domain registration with the names of these name servers.
 *
 * - Enables auto renew, so your domain registration will renew automatically each
 * year. We'll notify you in advance of the renewal date so you can choose whether
 * to renew the registration.
 *
 * - Optionally enables privacy protection, so WHOIS queries return contact for the registrar
 * or the phrase "REDACTED FOR PRIVACY", or "On behalf of owner."
 * If you don't enable privacy protection, WHOIS queries return the information
 * that you entered for the administrative, registrant, and technical
 * contacts.
 *
 * While some domains may allow different privacy settings per contact, we recommend
 * specifying the same privacy setting for all contacts.
 *
 * - If registration is successful, returns an operation ID that you can use to
 * track the progress and completion of the action. If the request is not completed
 * successfully, the domain registrant is notified by email.
 *
 * - Charges your Amazon Web Services account an amount based on the top-level
 * domain. For more information, see Amazon Route 53 Pricing.
 */
export const registerDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RegisterDomainRequest,
    output: RegisterDomainResponse,
    errors: [
        DomainLimitExceeded,
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * Rejects the transfer of a domain from another Amazon Web Services account to the
 * current Amazon Web Services account. You initiate a transfer betweenAmazon Web Services accounts using TransferDomainToAnotherAwsAccount.
 *
 * Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
 * `Domain Transfer from Aws Account 111122223333 has been cancelled`.
 */
export const rejectDomainTransferFromAnotherAwsAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RejectDomainTransferFromAnotherAwsAccountRequest,
    output: RejectDomainTransferFromAnotherAwsAccountResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * This operation renews a domain for the specified number of years. The cost of renewing
 * your domain is billed to your Amazon Web Services account.
 *
 * We recommend that you renew your domain several weeks before the expiration date. Some
 * TLD registries delete domains before the expiration date if you haven't renewed far
 * enough in advance. For more information about renewing domain registration, see Renewing
 * Registration for a Domain in the Amazon Route 53 Developer
 * Guide.
 */
export const renewDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RenewDomainRequest,
    output: RenewDomainResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * For operations that require confirmation that the email address for the registrant
 * contact is valid, such as registering a new domain, this operation resends the
 * confirmation email to the current email address for the registrant contact.
 */
export const resendContactReachabilityEmail = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ResendContactReachabilityEmailRequest,
    output: ResendContactReachabilityEmailResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * Resend the form of authorization email for this operation.
 */
export const resendOperationAuthorization = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ResendOperationAuthorizationRequest,
    output: ResendOperationAuthorizationResponse,
    errors: [InvalidInput],
}));
/**
 * This operation returns the authorization code for the domain. To transfer a domain to
 * another registrar, you provide this value to the new registrar.
 */
export const retrieveDomainAuthCode = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RetrieveDomainAuthCodeRequest,
    output: RetrieveDomainAuthCodeResponse,
    errors: [InvalidInput, UnsupportedTLD],
}));
/**
 * Transfers a domain from another registrar to Amazon Route 53.
 *
 * For more information about transferring domains, see the following topics:
 *
 * - For transfer requirements, a detailed procedure, and information about viewing
 * the status of a domain that you're transferring to Route 53, see Transferring Registration for a Domain to Amazon Route 53 in the
 * *Amazon Route 53 Developer Guide*.
 *
 * - For information about how to transfer a domain from one Amazon Web Services account to another, see TransferDomainToAnotherAwsAccount.
 *
 * - For information about how to transfer a domain to another domain registrar,
 * see Transferring a Domain from Amazon Route 53 to Another Registrar in
 * the *Amazon Route 53 Developer Guide*.
 *
 * During the transfer of any country code top-level domains (ccTLDs) to Route 53, except for .cc and .tv,
 * updates to the owner contact are ignored and the owner contact data from the registry is used.
 * You can
 * update the owner contact after the transfer is complete. For more information, see
 * UpdateDomainContact.
 *
 * If the registrar for your domain is also the DNS service provider for the domain, we
 * highly recommend that you transfer your DNS service to Route 53 or to another DNS
 * service provider before you transfer your registration. Some registrars provide free DNS
 * service when you purchase a domain registration. When you transfer the registration, the
 * previous registrar will not renew your domain registration and could end your DNS
 * service at any time.
 *
 * If the registrar for your domain is also the DNS service provider for the domain
 * and you don't transfer DNS service to another provider, your website, email, and the
 * web applications associated with the domain might become unavailable.
 *
 * If the transfer is successful, this method returns an operation ID that you can use to
 * track the progress and completion of the action. If the transfer doesn't complete
 * successfully, the domain registrant will be notified by email.
 */
export const transferDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TransferDomainRequest,
    output: TransferDomainResponse,
    errors: [
        DomainLimitExceeded,
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * Transfers a domain from the current Amazon Web Services account to another Amazon Web Services account. Note the following:
 *
 * - The Amazon Web Services account that you're transferring the domain to must
 * accept the transfer. If the other account doesn't accept the transfer within 3
 * days, we cancel the transfer. See AcceptDomainTransferFromAnotherAwsAccount.
 *
 * - You can cancel the transfer before the other account accepts it. See CancelDomainTransferToAnotherAwsAccount.
 *
 * - The other account can reject the transfer. See RejectDomainTransferFromAnotherAwsAccount.
 *
 * When you transfer a domain from one Amazon Web Services account to another, Route
 * 53 doesn't transfer the hosted zone that is associated with the domain. DNS
 * resolution isn't affected if the domain and the hosted zone are owned by separate
 * accounts, so transferring the hosted zone is optional. For information about
 * transferring the hosted zone to another Amazon Web Services account, see Migrating a
 * Hosted Zone to a Different Amazon Web Services Account in the
 * *Amazon Route 53 Developer Guide*.
 *
 * Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
 * `Domain Transfer from Aws Account 111122223333 has been cancelled`.
 */
export const transferDomainToAnotherAwsAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TransferDomainToAnotherAwsAccountRequest,
    output: TransferDomainToAnotherAwsAccountResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        UnsupportedTLD,
    ],
}));
/**
 * This operation updates the contact information for a particular domain. You must
 * specify information for at least one contact: registrant, administrator, or
 * technical.
 *
 * If the update is successful, this method returns an operation ID that you can use to
 * track the progress and completion of the operation. If the request is not completed
 * successfully, the domain registrant will be notified by email.
 */
export const updateDomainContact = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateDomainContactRequest,
    output: UpdateDomainContactResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * This operation updates the specified domain contact's privacy setting. When privacy
 * protection is enabled, your contact information is replaced with contact information for
 * the registrar or with the phrase "REDACTED FOR PRIVACY", or "On behalf of owner."
 *
 * While some domains may allow different privacy settings per contact, we recommend
 * specifying the same privacy setting for all contacts.
 *
 * This operation affects only the contact information for the specified contact type
 * (administrative, registrant, or technical). If the request succeeds, Amazon Route 53
 * returns an operation ID that you can use with GetOperationDetail to track the progress and completion of the action. If
 * the request doesn't complete successfully, the domain registrant will be notified by
 * email.
 *
 * By disabling the privacy service via API, you consent to the publication of the
 * contact information provided for this domain via the public WHOIS database. You
 * certify that you are the registrant of this domain name and have the authority to
 * make this decision. You may withdraw your consent at any time by enabling privacy
 * protection using either `UpdateDomainContactPrivacy` or the Route 53
 * console. Enabling privacy protection removes the contact information provided for
 * this domain from the WHOIS database. For more information on our privacy practices,
 * see https://aws.amazon.com/privacy/.
 */
export const updateDomainContactPrivacy = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateDomainContactPrivacyRequest,
    output: UpdateDomainContactPrivacyResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * This operation replaces the current set of name servers for the domain with the
 * specified set of name servers. If you use Amazon Route 53 as your DNS service, specify
 * the four name servers in the delegation set for the hosted zone for the domain.
 *
 * If successful, this operation returns an operation ID that you can use to track the
 * progress and completion of the action. If the request is not completed successfully, the
 * domain registrant will be notified by email.
 */
export const updateDomainNameservers = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateDomainNameserversRequest,
    output: UpdateDomainNameserversResponse,
    errors: [
        DuplicateRequest,
        InvalidInput,
        OperationLimitExceeded,
        TLDRulesViolation,
        UnsupportedTLD,
    ],
}));
/**
 * This operation adds or updates tags for a specified domain.
 *
 * All tag operations are eventually consistent; subsequent operations might not
 * immediately represent all issued operations.
 */
export const updateTagsForDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateTagsForDomainRequest,
    output: UpdateTagsForDomainResponse,
    errors: [InvalidInput, OperationLimitExceeded, UnsupportedTLD],
}));
/**
 * Returns all the domain-related billing records for the current Amazon Web Services account for a specified period
 */
export const viewBilling = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ViewBillingRequest,
    output: ViewBillingResponse,
    errors: [InvalidInput],
    pagination: {
        inputToken: "Marker",
        outputToken: "NextPageMarker",
        items: "BillingRecords",
        pageSize: "MaxItems",
    },
}));
//# sourceMappingURL=route-53-domains.js.map