@distilled.cloud/ovh 0.0.0 → 1.0.0-rc.10

package/lib/services/domain.d.ts

@@ -0,0 +1,2995 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type OvhOpError, type OvhOpContext } from "../protocol.ts";
+export type { OvhOpError, OvhOpContext };
+/** Type of claim notice */
+export type DomainApproveTypeEnum = "accept" | "reject";
+export declare const DomainApproveTypeEnum: any;
+export interface ApproveDomainOutgoingTransferRequest {
+    /** Service name */
+    serviceName: string;
+    /** Approve type for outgoing transfer */
+    approveType?: DomainApproveTypeEnum | (string & {});
+    /** Token given by email to validate identity */
+    ident?: string;
+}
+export declare const ApproveDomainOutgoingTransferRequest: S.Schema<ApproveDomainOutgoingTransferRequest>;
+export interface ApproveDomainOutgoingTransferResponse {
+}
+export declare const ApproveDomainOutgoingTransferResponse: S.Schema<ApproveDomainOutgoingTransferResponse>;
+export interface CancelDomainTaskRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const CancelDomainTaskRequest: S.Schema<CancelDomainTaskRequest>;
+export interface CancelDomainTaskResponse {
+}
+export declare const CancelDomainTaskResponse: S.Schema<CancelDomainTaskResponse>;
+export interface CancelDomainZoneTaskRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const CancelDomainZoneTaskRequest: S.Schema<CancelDomainZoneTaskRequest>;
+export interface CancelDomainZoneTaskResponse {
+}
+export declare const CancelDomainZoneTaskResponse: S.Schema<CancelDomainZoneTaskResponse>;
+export interface ChangePasswordDynDnsLoginRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Login */
+    login: string;
+    /** New password of the DynHost login */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const ChangePasswordDynDnsLoginRequest: S.Schema<ChangePasswordDynDnsLoginRequest>;
+export interface ChangePasswordDynDnsLoginResponse {
+}
+export declare const ChangePasswordDynDnsLoginResponse: S.Schema<ChangePasswordDynDnsLoginResponse>;
+/** An action to execute on a domain name */
+export type DomainActionEnum = "create" | "trade" | "transfer" | "update";
+export declare const DomainActionEnum: any;
+/** Countries a nichandle can choose */
+export type NichandleCountryEnum = "AC" | "AD" | "AE" | "AF" | "AG" | "AI" | "AL" | "AM" | "AO" | "AQ" | "AR" | "AS" | "AT" | "AU" | "AW" | "AX" | "AZ" | "BA" | "BB" | "BD" | "BE" | "BF" | "BG" | "BH" | "BI" | "BJ" | "BL" | "BM" | "BN" | "BO" | "BQ" | "BR" | "BS" | "BT" | "BW" | "BY" | "BZ" | "CA" | "CC" | "CD" | "CF" | "CG" | "CH" | "CI" | "CK" | "CL" | "CM" | "CN" | "CO" | "CR" | "CU" | "CV" | "CW" | "CX" | "CY" | "CZ" | "DE" | "DG" | "DJ" | "DK" | "DM" | "DO" | "DZ" | "EA" | "EC" | "EE" | "EG" | "EH" | "ER" | "ES" | "ET" | "FI" | "FJ" | "FK" | "FM" | "FO" | "FR" | "GA" | "GB" | "GD" | "GE" | "GF" | "GG" | "GH" | "GI" | "GL" | "GM" | "GN" | "GP" | "GQ" | "GR" | "GS" | "GT" | "GU" | "GW" | "GY" | "HK" | "HN" | "HR" | "HT" | "HU" | "IC" | "ID" | "IE" | "IL" | "IM" | "IN" | "IO" | "IQ" | "IR" | "IS" | "IT" | "JE" | "JM" | "JO" | "JP" | "KE" | "KG" | "KH" | "KI" | "KM" | "KN" | "KP" | "KR" | "KW" | "KY" | "KZ" | "LA" | "LB" | "LC" | "LI" | "LK" | "LR" | "LS" | "LT" | "LU" | "LV" | "LY" | "MA" | "MC" | "MD" | "ME" | "MF" | "MG" | "MH" | "MK" | "ML" | "MM" | "MN" | "MO" | "MP" | "MQ" | "MR" | "MS" | "MT" | "MU" | "MV" | "MW" | "MX" | "MY" | "MZ" | "NA" | "NC" | "NE" | "NF" | "NG" | "NI" | "NL" | "NO" | "NP" | "NR" | "NU" | "NZ" | "OM" | "PA" | "PE" | "PF" | "PG" | "PH" | "PK" | "PL" | "PM" | "PN" | "PR" | "PS" | "PT" | "PW" | "PY" | "QA" | "RE" | "RO" | "RS" | "RU" | "RW" | "SA" | "SB" | "SC" | "SD" | "SE" | "SG" | "SH" | "SI" | "SJ" | "SK" | "SL" | "SM" | "SN" | "SO" | "SR" | "SS" | "ST" | "SV" | "SX" | "SY" | "SZ" | "TA" | "TC" | "TD" | "TF" | "TG" | "TH" | "TJ" | "TK" | "TL" | "TM" | "TN" | "TO" | "TR" | "TT" | "TV" | "TW" | "TZ" | "UA" | "UG" | "UM" | "UNKNOWN" | "US" | "UY" | "UZ" | "VA" | "VC" | "VE" | "VG" | "VI" | "VN" | "VU" | "WF" | "WS" | "XK" | "YE" | "YT" | "ZA" | "ZM" | "ZW";
+export declare const NichandleCountryEnum: any;
+/** Languages a nichandle can choose */
+export type NichandleLanguageEnum = "cs_CZ" | "de_DE" | "en_AU" | "en_CA" | "en_GB" | "en_IE" | "en_US" | "es_ES" | "fi_FI" | "fr_CA" | "fr_FR" | "fr_MA" | "fr_SN" | "fr_TN" | "it_IT" | "lt_LT" | "nl_NL" | "pl_PL" | "pt_PT";
+export declare const NichandleLanguageEnum: any;
+/** Legal forms a nichandle can be registered as */
+export type NichandleLegalFormEnum = "administration" | "association" | "corporation" | "individual" | "other" | "personalcorporation";
+export declare const NichandleLegalFormEnum: any;
+/** All phone type a person can choose */
+export type NichandlePhoneTypeEnum = "landline" | "mobile";
+export declare const NichandlePhoneTypeEnum: any;
+/** All genders a person can choose */
+export type NichandleGenderEnum = "female" | "male";
+export declare const NichandleGenderEnum: any;
+/** Details about your OVH identifier */
+export interface NichandleNichandleInput {
+    /** Address of nichandle */
+    address?: string | null;
+    /** Area of nichandle */
+    area?: string | null;
+    /** City of birth */
+    birthCity?: string | null;
+    /** Birth date */
+    birthDay?: string | null;
+    /** City of nichandle */
+    city?: string | null;
+    /** Company National Identification Number */
+    companyNationalIdentificationNumber?: string | null;
+    /** Complementary Address */
+    complementaryAddress?: string | null;
+    /** Corporation type */
+    corporationType?: string | null;
+    /** Customer country */
+    country?: NichandleCountryEnum | (string & {});
+    /** Display name shown instead of the organisation name. */
+    displayName?: string | null;
+    /** Fax number */
+    fax?: string | null;
+    /** First name */
+    firstname?: string | null;
+    /** Italian SDI */
+    italianSDI?: string | null;
+    /** Language */
+    language?: NichandleLanguageEnum | (string & {}) | null;
+    /** Customer legal form */
+    legalform?: NichandleLegalFormEnum | (string & {});
+    /** Customer name */
+    name?: string | null;
+    /** National Identification Number */
+    nationalIdentificationNumber?: string | null;
+    /** Name of organisation */
+    organisation?: string | null;
+    /** Phone number */
+    phone?: string | null;
+    phoneCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Type of phone(mobile, landline) */
+    phoneType?: NichandlePhoneTypeEnum | (string & {}) | null;
+    /** Customer purpose of purchase */
+    purposeOfPurchase?: string | null;
+    /** Gender */
+    sex?: NichandleGenderEnum | (string & {}) | null;
+    /** Spare email */
+    spareEmail?: string | null;
+    /** VAT number */
+    vat?: string | null;
+    /** Zipcode */
+    zip?: string | null;
+}
+export declare const NichandleNichandleInput: S.Schema<NichandleNichandleInput>;
+/** The extra data contain additional rule data fields */
+export interface DomainConfigurationRulesRuleExtraData {
+    /** Whether you accept the domain specific conditions or not */
+    acceptCondition?: boolean | null;
+    /** The auth info code for the domain */
+    authInfo?: string | null;
+}
+export declare const DomainConfigurationRulesRuleExtraData: S.Schema<DomainConfigurationRulesRuleExtraData>;
+/** Missing description */
+export interface DomainContactAddress {
+    /** City */
+    city?: string | null;
+    /** Country */
+    country?: NichandleCountryEnum | (string & {}) | null;
+    /** Address line 1 */
+    line1?: string | null;
+    /** Address line 2 */
+    line2?: string | null;
+    /** Address line 3 */
+    line3?: string | null;
+    /** Others details */
+    otherDetails?: string | null;
+    /** Province */
+    province?: string | null;
+    /** Zip code */
+    zip?: string | null;
+}
+export declare const DomainContactAddress: S.Schema<DomainContactAddress>;
+/** A contact contains the personal data of a user */
+export interface DomainContactInput {
+    /** Country of lawyer accreditation */
+    accreditationCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Lawyer accreditation number */
+    accreditationId?: string | null;
+    /** Organism of lawyer accreditation */
+    accreditationOrganism?: string | null;
+    /** Year of lawyer accreditation */
+    accreditationYear?: number | null;
+    /** The address of the contact */
+    address?: DomainContactAddress | null;
+    /** City of birth */
+    birthCity?: string | null;
+    /** Birth Country */
+    birthCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Birth date */
+    birthDay?: string | null;
+    /** Birth Zipcode */
+    birthZip?: string | null;
+    /** Cellphone number */
+    cellPhone?: string | null;
+    /** Company National Identification Number */
+    companyNationalIdentificationNumber?: string | null;
+    /** Email address */
+    email?: string | null;
+    /** Enterprise identifier */
+    enterpriseId?: string | null;
+    /** Fax number */
+    fax?: string | null;
+    /** First name */
+    firstName?: string | null;
+    /** Gender */
+    gender?: NichandleGenderEnum | (string & {}) | null;
+    /** INSEE identifier */
+    insee?: string | null;
+    /** Language */
+    language?: NichandleLanguageEnum | (string & {}) | null;
+    /** Last name */
+    lastName?: string | null;
+    legalForm?: NichandleLegalFormEnum | (string & {}) | null;
+    /** category of legalForm */
+    legalFormCategory?: string | null;
+    /** National Identification Number */
+    nationalIdentificationNumber?: string | null;
+    /** Nationality */
+    nationality?: NichandleCountryEnum | (string & {}) | null;
+    /** To whom is the organisation accountable */
+    organisationAccountable?: string | null;
+    /** What is the source of funding */
+    organisationFunding?: string | null;
+    /** Explain the source of funding if organisationFunding is other */
+    organisationFundingOther?: string | null;
+    /** Name of organisation */
+    organisationName?: string | null;
+    /** Role of your organisation */
+    organisationRole?: string | null;
+    /** Explain the role of your organisation if organisationRole is other */
+    organisationRoleOther?: string | null;
+    /** Status of the staff */
+    organisationStaffStatus?: string | null;
+    /** Explain the status of the staff if organisationStaffStatus is other */
+    organisationStaffStatusOther?: string | null;
+    /** type of organisation */
+    organisationType?: string | null;
+    /** Explain the type of organisation if organisationType is other */
+    organisationTypeOther?: string | null;
+    /** Phone number */
+    phone?: string | null;
+    /** Type of registrant document */
+    registrantDocumentType?: string | null;
+    /** Explain the type of registrant document if registrantDocumentType is other */
+    registrantDocumentTypeOther?: string | null;
+    /** The role in the organisation */
+    roleInOrganisation?: string | null;
+    /** Trademark related to the contact */
+    trademarkId?: string | null;
+    /** VAT number */
+    vat?: string | null;
+    /** Website */
+    website?: string | null;
+}
+export declare const DomainContactInput: S.Schema<DomainContactInput>;
+export interface CheckDomainConfigurationRuleRequest {
+    /** Depending on the action, the applied rule will change (transfer vs create) */
+    action: DomainActionEnum | (string & {});
+    /** The domain to check the rule data for */
+    domain: string;
+    /** The admin contact data */
+    adminAccount?: NichandleNichandleInput | null;
+    /** The extra data of the rule */
+    extras?: DomainConfigurationRulesRuleExtraData | null;
+    /** The owner contact data */
+    owner?: DomainContactInput | null;
+    /** The tech contact data */
+    techAccount?: NichandleNichandleInput | null;
+}
+export declare const CheckDomainConfigurationRuleRequest: S.Schema<CheckDomainConfigurationRuleRequest>;
+export interface CheckDomainConfigurationRuleResponse {
+}
+export declare const CheckDomainConfigurationRuleResponse: S.Schema<CheckDomainConfigurationRuleResponse>;
+/** All future uses you can provide for a service termination */
+export type ServiceTerminationFutureUseEnum = "NOT_REPLACING_SERVICE" | "OTHER" | "SUBSCRIBE_AN_OTHER_SERVICE" | "SUBSCRIBE_OTHER_KIND_OF_SERVICE_WITH_COMPETITOR" | "SUBSCRIBE_SIMILAR_SERVICE_WITH_COMPETITOR";
+export declare const ServiceTerminationFutureUseEnum: any;
+/** All reasons you can provide for a service termination */
+export type ServiceTerminationReasonEnum = "FEATURES_DONT_SUIT_ME" | "LACK_OF_PERFORMANCES" | "MIGRATED_TO_ANOTHER_OVH_PRODUCT" | "MIGRATED_TO_COMPETITOR" | "NOT_ENOUGH_RECOGNITION" | "NOT_NEEDED_ANYMORE" | "NOT_RELIABLE" | "NO_ANSWER" | "OTHER" | "PRODUCT_DIMENSION_DONT_SUIT_ME" | "PRODUCT_TOOLS_DONT_SUIT_ME" | "TOO_EXPENSIVE" | "TOO_HARD_TO_USE" | "UNSATIFIED_BY_CUSTOMER_SUPPORT";
+export declare const ServiceTerminationReasonEnum: any;
+export interface ConfirmDomainZoneTerminationRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Commentary about your termination request */
+    commentary?: string;
+    /** Commentary about your future use */
+    commentaryFutureUse?: string;
+    /** Commentary about your reason for termination request */
+    commentaryReason?: string;
+    /** All future uses you can provide for a service termination */
+    futureUse?: ServiceTerminationFutureUseEnum | (string & {});
+    /** All reasons you can provide for a service termination */
+    reason?: ServiceTerminationReasonEnum | (string & {});
+    /** The termination token sent by email to the admin contact */
+    token: string;
+}
+export declare const ConfirmDomainZoneTerminationRequest: S.Schema<ConfirmDomainZoneTerminationRequest>;
+export type ConfirmDomainZoneTerminationResponse = string;
+export declare const ConfirmDomainZoneTerminationResponse: S.Schema<ConfirmDomainZoneTerminationResponse>;
+export interface CreateContactRequest {
+    /** Country of lawyer accreditation */
+    accreditationCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Lawyer accreditation number */
+    accreditationId?: string | null;
+    /** Organism of lawyer accreditation */
+    accreditationOrganism?: string | null;
+    /** Year of lawyer accreditation */
+    accreditationYear?: number | null;
+    /** The address of the contact */
+    address?: DomainContactAddress | null;
+    /** City of birth */
+    birthCity?: string | null;
+    /** Birth Country */
+    birthCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Birth date */
+    birthDay?: string | null;
+    /** Birth Zipcode */
+    birthZip?: string | null;
+    /** Cellphone number */
+    cellPhone?: string | null;
+    /** Company National Identification Number */
+    companyNationalIdentificationNumber?: string | null;
+    /** Email address */
+    email?: string | null;
+    /** Enterprise identifier */
+    enterpriseId?: string | null;
+    /** Fax number */
+    fax?: string | null;
+    /** First name */
+    firstName?: string | null;
+    /** Gender */
+    gender?: NichandleGenderEnum | (string & {}) | null;
+    /** INSEE identifier */
+    insee?: string | null;
+    /** Language */
+    language?: NichandleLanguageEnum | (string & {}) | null;
+    /** Last name */
+    lastName?: string | null;
+    legalForm?: NichandleLegalFormEnum | (string & {}) | null;
+    /** category of legalForm */
+    legalFormCategory?: string | null;
+    /** National Identification Number */
+    nationalIdentificationNumber?: string | null;
+    /** Nationality */
+    nationality?: NichandleCountryEnum | (string & {}) | null;
+    /** To whom is the organisation accountable */
+    organisationAccountable?: string | null;
+    /** What is the source of funding */
+    organisationFunding?: string | null;
+    /** Explain the source of funding if organisationFunding is other */
+    organisationFundingOther?: string | null;
+    /** Name of organisation */
+    organisationName?: string | null;
+    /** Role of your organisation */
+    organisationRole?: string | null;
+    /** Explain the role of your organisation if organisationRole is other */
+    organisationRoleOther?: string | null;
+    /** Status of the staff */
+    organisationStaffStatus?: string | null;
+    /** Explain the status of the staff if organisationStaffStatus is other */
+    organisationStaffStatusOther?: string | null;
+    /** type of organisation */
+    organisationType?: string | null;
+    /** Explain the type of organisation if organisationType is other */
+    organisationTypeOther?: string | null;
+    /** Phone number */
+    phone?: string | null;
+    /** Type of registrant document */
+    registrantDocumentType?: string | null;
+    /** Explain the type of registrant document if registrantDocumentType is other */
+    registrantDocumentTypeOther?: string | null;
+    /** The role in the organisation */
+    roleInOrganisation?: string | null;
+    /** Trademark related to the contact */
+    trademarkId?: string | null;
+    /** VAT number */
+    vat?: string | null;
+    /** Website */
+    website?: string | null;
+}
+export declare const CreateContactRequest: S.Schema<CreateContactRequest>;
+/** A contact contains the personal data of a user */
+export interface DomainContact {
+    /** Country of lawyer accreditation */
+    accreditationCountry?: NichandleCountryEnum | null;
+    /** Lawyer accreditation number */
+    accreditationId?: string | null;
+    /** Organism of lawyer accreditation */
+    accreditationOrganism?: string | null;
+    /** Year of lawyer accreditation */
+    accreditationYear?: number | null;
+    /** The address of the contact */
+    address?: DomainContactAddress | null;
+    /** City of birth */
+    birthCity?: string | null;
+    /** Birth Country */
+    birthCountry?: NichandleCountryEnum | null;
+    /** Birth date */
+    birthDay?: string | null;
+    /** Birth Zipcode */
+    birthZip?: string | null;
+    /** Cellphone number */
+    cellPhone?: string | null;
+    /** Company National Identification Number */
+    companyNationalIdentificationNumber?: string | null;
+    /** Email address */
+    email?: string | null;
+    /** Enterprise identifier */
+    enterpriseId?: string | null;
+    /** Fax number */
+    fax?: string | null;
+    /** First name */
+    firstName?: string | null;
+    /** Gender */
+    gender?: NichandleGenderEnum | null;
+    /** Unique identifier */
+    id?: number;
+    /** INSEE identifier */
+    insee?: string | null;
+    /** Language */
+    language?: NichandleLanguageEnum | null;
+    /** Last name */
+    lastName?: string | null;
+    legalForm?: NichandleLegalFormEnum | null;
+    /** category of legalForm */
+    legalFormCategory?: string | null;
+    /** National Identification Number */
+    nationalIdentificationNumber?: string | null;
+    /** Nationality */
+    nationality?: NichandleCountryEnum | null;
+    /** To whom is the organisation accountable */
+    organisationAccountable?: string | null;
+    /** What is the source of funding */
+    organisationFunding?: string | null;
+    /** Explain the source of funding if organisationFunding is other */
+    organisationFundingOther?: string | null;
+    /** Name of organisation */
+    organisationName?: string | null;
+    /** Role of your organisation */
+    organisationRole?: string | null;
+    /** Explain the role of your organisation if organisationRole is other */
+    organisationRoleOther?: string | null;
+    /** Status of the staff */
+    organisationStaffStatus?: string | null;
+    /** Explain the status of the staff if organisationStaffStatus is other */
+    organisationStaffStatusOther?: string | null;
+    /** type of organisation */
+    organisationType?: string | null;
+    /** Explain the type of organisation if organisationType is other */
+    organisationTypeOther?: string | null;
+    /** Phone number */
+    phone?: string | null;
+    /** Type of registrant document */
+    registrantDocumentType?: string | null;
+    /** Explain the type of registrant document if registrantDocumentType is other */
+    registrantDocumentTypeOther?: string | null;
+    /** The role in the organisation */
+    roleInOrganisation?: string | null;
+    /** Trademark related to the contact */
+    trademarkId?: string | null;
+    /** VAT number */
+    vat?: string | null;
+    /** Website */
+    website?: string | null;
+}
+export declare const DomainContact: S.Schema<DomainContact>;
+export interface CreateDomainChangeContactRequest {
+    /** Service name */
+    serviceName: string;
+    /** The contact to set as admin contact */
+    contactAdmin?: string;
+    /** The contact to set as billing contact */
+    contactBilling?: string;
+    /** The contact to set as tech contact */
+    contactTech?: string;
+}
+export declare const CreateDomainChangeContactRequest: S.Schema<CreateDomainChangeContactRequest>;
+export type CreateDomainChangeContactResponseBodyList = Array<number>;
+export declare const CreateDomainChangeContactResponseBodyList: S.Schema<CreateDomainChangeContactResponseBodyList>;
+export type CreateDomainChangeContactResponse = CreateDomainChangeContactResponseBodyList;
+export declare const CreateDomainChangeContactResponse: S.Schema<CreateDomainChangeContactResponse>;
+export interface CreateDomainDataSmdRequest {
+    /** SMD file content in base64 */
+    data: string;
+}
+export declare const CreateDomainDataSmdRequest: S.Schema<CreateDomainDataSmdRequest>;
+/** Representation of a protected label */
+export interface DomainDataSmdSmdLabel {
+    /** Label that is protected */
+    label?: string;
+    /** Trademark associated to the protected label */
+    trademark?: string;
+}
+export declare const DomainDataSmdSmdLabel: S.Schema<DomainDataSmdSmdLabel>;
+/** List of the labels that are protect with that SMD file */
+export type DomainDataSmdSmdProtectedLabelsList = Array<DomainDataSmdSmdLabel>;
+export declare const DomainDataSmdSmdProtectedLabelsList: S.Schema<DomainDataSmdSmdProtectedLabelsList>;
+/** Representation of a SMD file */
+export interface DomainDataSmdSmd {
+    /** SMD file content */
+    data?: string;
+    /** UUID of SMD file */
+    id?: string;
+    /** Date when information about SMD file aren't valid anymore */
+    notAfter?: string;
+    /** Date before when information about SMD file aren't valid yet */
+    notBefore?: string;
+    /** List of the labels that are protect with that SMD file */
+    protectedLabels?: DomainDataSmdSmdProtectedLabelsList;
+    /** TMCH Internal identifier */
+    smdId?: string;
+}
+export declare const DomainDataSmdSmd: S.Schema<DomainDataSmdSmd>;
+/** DNSSEC Algorithm 3: DSA 5: RSASHA1 6: DSA-NSEC3-SHA1 7: RSASHA1-NSEC3-SHA1 8: RSASHA256 10: RSASHA512 12: ECC-GOST 13: ECDSAP256SHA256 14: ECDSAP384SHA384 15: ED25519 16: ED448 */
+export type DnssecKeyAlgorithmEnum = 3 | 5 | 6 | 7 | 8 | 10 | 12 | 13 | 14 | 15 | 16;
+export declare const DnssecKeyAlgorithmEnum: any;
+/** DNSSEC Key Flag Type: 256=ZSK (Zone Signing Key), 257=KSK (Key Signing Key) */
+export type DnssecKeyFlagEnum = 256 | 257;
+export declare const DnssecKeyFlagEnum: any;
+/** Domain's DNSSEC Key */
+export interface DnssecKeyInput {
+    /** Algorithm number of the DNSSEC key */
+    algorithm?: DnssecKeyAlgorithmEnum | (number & {});
+    /** Flag of the DNSSEC key */
+    flags?: DnssecKeyFlagEnum | (number & {});
+    /** Public key */
+    publicKey?: string;
+    /** Tag of the DNSSEC key */
+    tag?: number;
+}
+export declare const DnssecKeyInput: S.Schema<DnssecKeyInput>;
+/** New Keys */
+export type CreateDomainDsRecordRequestKeysList = Array<DnssecKeyInput>;
+export declare const CreateDomainDsRecordRequestKeysList: S.Schema<CreateDomainDsRecordRequestKeysList>;
+export interface CreateDomainDsRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** New Keys */
+    keys: CreateDomainDsRecordRequestKeysList;
+}
+export declare const CreateDomainDsRecordRequest: S.Schema<CreateDomainDsRecordRequest>;
+/** Operation status */
+export type DomainOperationStatusEnum = "cancelled" | "doing" | "done" | "error" | "problem" | "todo";
+export declare const DomainOperationStatusEnum: any;
+/** Operation type */
+export type DomainOperationTypeEnum = "alldom" | "domain";
+export declare const DomainOperationTypeEnum: any;
+/** Tasks associated to domain */
+export interface DomainTask {
+    /** Can accelerate the task */
+    canAccelerate?: boolean;
+    /** Can cancel the task */
+    canCancel?: boolean;
+    /** Can relaunch the task */
+    canRelaunch?: boolean;
+    /** Comment about the task */
+    comment?: string | null;
+    /** Creation date of the task */
+    creationDate?: string;
+    /** Domain of the task */
+    domain?: string | null;
+    /** Done date of the task */
+    doneDate?: string | null;
+    /** Function of the task */
+    function?: string;
+    /** Id of the task */
+    id?: number;
+    /** Last update date of the task */
+    lastUpdate?: string;
+    /** Status of the task */
+    status?: DomainOperationStatusEnum;
+    /** Todo date of the task */
+    todoDate?: string;
+    /** type of the task */
+    type?: DomainOperationTypeEnum;
+}
+export declare const DomainTask: S.Schema<DomainTask>;
+/** IP addresses of the glue record */
+export type CreateDomainGlueRecordRequestIpsList = Array<string>;
+export declare const CreateDomainGlueRecordRequestIpsList: S.Schema<CreateDomainGlueRecordRequestIpsList>;
+export interface CreateDomainGlueRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Host of the glue record */
+    host: string;
+    /** IP addresses of the glue record */
+    ips: CreateDomainGlueRecordRequestIpsList;
+}
+export declare const CreateDomainGlueRecordRequest: S.Schema<CreateDomainGlueRecordRequest>;
+/** Name server input data */
+export interface DomainNameServerNameServerInput {
+    /** Host */
+    host?: string;
+    /** IP address */
+    ip?: string | null;
+}
+export declare const DomainNameServerNameServerInput: S.Schema<DomainNameServerNameServerInput>;
+/** Name servers to create */
+export type CreateDomainNameServerRequestNameServerList = Array<DomainNameServerNameServerInput>;
+export declare const CreateDomainNameServerRequestNameServerList: S.Schema<CreateDomainNameServerRequestNameServerList>;
+export interface CreateDomainNameServerRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name servers to create */
+    nameServer: CreateDomainNameServerRequestNameServerList;
+}
+export declare const CreateDomainNameServerRequest: S.Schema<CreateDomainNameServerRequest>;
+/** Owner contact reference for a domain order: an OVH contact resource, not a NIC handle. */
+export interface DomainOrderContactOwner {
+    /** Numeric identifier of the OVH contact resource (e.g. obtained from /me/contact). Distinct from a NIC handle such as xxxxx-ovh. */
+    id?: number | null;
+}
+export declare const DomainOrderContactOwner: S.Schema<DomainOrderContactOwner>;
+/** Admin, tech and owner contacts for a domain order. admin and tech are OVH NIC handles (e.g. xxxxx-ovh); owner is an OVH contact resource referenced by its numeric id (see /me/contact), not a NIC handle. Billing is forced to the customer code by the server and is not exposed. */
+export interface DomainOrderContacts {
+    /** Administrative contact, given as an OVH NIC handle (e.g. xxxxx-ovh). Defaults to the calling customer's NIC if omitted. */
+    admin?: string | null;
+    /** Owner contact of the domain. Unlike admin/tech which are NIC handles, the owner is an OVH contact resource referenced by its numeric id. */
+    owner?: DomainOrderContactOwner | null;
+    /** Technical contact, given as an OVH NIC handle (e.g. xxxxx-ovh). Defaults to the admin contact if omitted. */
+    tech?: string | null;
+}
+export declare const DomainOrderContacts: S.Schema<DomainOrderContacts>;
+/** List of DNS servers (hostnames) to set on the domain. Optional: if omitted, OVHcloud's recommended DNS servers for the domain are used. */
+export type CreateDomainOrderRequestDnsList = Array<string>;
+export declare const CreateDomainOrderRequestDnsList: S.Schema<CreateDomainOrderRequestDnsList>;
+/** Currency code */
+export type OrderCurrencyCodeEnum = "AUD" | "CAD" | "CZK" | "EUR" | "GBP" | "INR" | "LTL" | "MAD" | "N/A" | "PLN" | "SGD" | "TND" | "USD" | "XOF" | "points";
+export declare const OrderCurrencyCodeEnum: any;
+/** Minimal price payload sent by the client to acknowledge the price seen, before placing the actual order */
+export interface DomainOrderPriceAcknowledge {
+    /** Currency code of the acknowledged price */
+    currencyCode: OrderCurrencyCodeEnum | (string & {});
+    /** The effective price acknowledged by the client */
+    value: number;
+}
+export declare const DomainOrderPriceAcknowledge: S.Schema<DomainOrderPriceAcknowledge>;
+/** Promotion codes to apply. Optional. */
+export type CreateDomainOrderRequestPromoCodesList = Array<string>;
+export declare const CreateDomainOrderRequestPromoCodesList: S.Schema<CreateDomainOrderRequestPromoCodesList>;
+/** DNS zone options for a domain order */
+export interface DomainOrderZoneOptions {
+    /** Enable Anycast on the DNS zone. Applied only when a new zone is created (create=true and no existing zone); ignored otherwise. */
+    anycast?: boolean | null;
+    /** Whether to create the DNS zone along with the domain. Defaults to true if omitted. */
+    create?: boolean | null;
+    /** Enable DNSSEC on the DNS zone. Applied only when a new zone is created (create=true and no existing zone); ignored otherwise. */
+    dnssec?: boolean | null;
+}
+export declare const DomainOrderZoneOptions: S.Schema<DomainOrderZoneOptions>;
+export interface CreateDomainOrderRequest {
+    /** If true, simulate the order and return the pricing without actually placing it. Default to false. */
+    dryRun?: boolean;
+    /** Admin, tech and owner contacts */
+    contacts?: DomainOrderContacts | null;
+    /** List of DNS servers (hostnames) to set on the domain. Optional: if omitted, OVHcloud's recommended DNS servers for the domain are used. */
+    dns?: CreateDomainOrderRequestDnsList | null;
+    /** Fully-qualified domain name to order, including the extension (e.g. example.com) */
+    domain: string;
+    /** Order duration in ISO-8601 format, whole years only (e.g. P1Y). Allowed values depend on the extension's registry configuration; an unsupported duration is rejected. Defaults to P1Y if omitted. */
+    duration?: string | null;
+    /** Price the customer acknowledged before placing the order. Required for aftermarket or premium domains, optional otherwise. Its value/currency must equal the retail price quoted for this domain (e.g. via a dryRun order); a mismatch rejects the order. */
+    priceAcknowledge?: DomainOrderPriceAcknowledge | null;
+    /** Promotion codes to apply. Optional. */
+    promoCodes?: CreateDomainOrderRequestPromoCodesList | null;
+    /** Acknowledgment that the customer waives the legal retractation period. Must be set to true to place the order. */
+    waiveRetractationPeriod?: boolean | null;
+    /** DNS zone options */
+    zone?: DomainOrderZoneOptions | null;
+}
+export declare const CreateDomainOrderRequest: S.Schema<CreateDomainOrderRequest>;
+/** A contract (terms) the customer subscribes to when placing a domain order */
+export interface DomainOrderContract {
+    /** Name of the contract (e.g. registration terms, general conditions of service) */
+    name?: string;
+    /** URL to the contract terms document (PDF) */
+    url?: string;
+}
+export declare const DomainOrderContract: S.Schema<DomainOrderContract>;
+/** Legal contracts (terms, as PDFs) the customer subscribes to with this order */
+export type DomainOrderOrderResponseContractsList = Array<DomainOrderContract>;
+export declare const DomainOrderOrderResponseContractsList: S.Schema<DomainOrderOrderResponseContractsList>;
+/** DNS servers set on the domain */
+export type DomainOrderOrderResponseDnsList = Array<string>;
+export declare const DomainOrderOrderResponseDnsList: S.Schema<DomainOrderOrderResponseDnsList>;
+/** Price with its currency and textual representation as returned by domain/order */
+export interface DomainOrderPrice {
+    /** Currency code */
+    currencyCode?: OrderCurrencyCodeEnum;
+    /** Human-readable price with currency, e.g. "6.08 EUR" */
+    text?: string;
+    /** The effective price as a number, e.g. 6.08 */
+    value?: number;
+}
+export declare const DomainOrderPrice: S.Schema<DomainOrderPrice>;
+/** Pricing breakdown with and without tax */
+export interface DomainOrderPricing {
+    /** Price excluding tax before any promotion */
+    basePriceWithoutTax?: DomainOrderPrice;
+    /** Total reduction applied by promotions, as a positive amount (0 if none) */
+    discount?: DomainOrderPrice;
+    /** Final price including tax, after any reduction */
+    finalPriceWithTax?: DomainOrderPrice;
+    /** Final price excluding tax, after any reduction */
+    finalPriceWithoutTax?: DomainOrderPrice;
+    /** Tax amount on the final price */
+    tax?: DomainOrderPrice;
+}
+export declare const DomainOrderPricing: S.Schema<DomainOrderPricing>;
+/** Response returned after placing a domain order */
+export interface DomainOrderOrderResponse {
+    /** Contacts attached to the order */
+    contacts?: DomainOrderContacts | null;
+    /** Legal contracts (terms, as PDFs) the customer subscribes to with this order */
+    contracts?: DomainOrderOrderResponseContractsList | null;
+    /** DNS servers set on the domain */
+    dns?: DomainOrderOrderResponseDnsList | null;
+    /** Ordered domain name */
+    domain?: string;
+    /** Order duration in ISO-8601 format, whole years only (e.g. P1Y) */
+    duration?: string;
+    /** Identifier of the created order, used with url to finalize and pay it */
+    orderId?: number | null;
+    /** Pricing breakdown of the order */
+    pricing?: DomainOrderPricing;
+    /** Payment/finalization URL where the customer completes and pays the order */
+    url?: string | null;
+    /** DNS zone options applied to the order */
+    zone?: DomainOrderZoneOptions | null;
+}
+export declare const DomainOrderOrderResponse: S.Schema<DomainOrderOrderResponse>;
+export interface CreateDomainTaskAccelerateRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const CreateDomainTaskAccelerateRequest: S.Schema<CreateDomainTaskAccelerateRequest>;
+export interface CreateDomainTaskAccelerateResponse {
+}
+export declare const CreateDomainTaskAccelerateResponse: S.Schema<CreateDomainTaskAccelerateResponse>;
+export interface CreateDomainTaskRelaunchRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const CreateDomainTaskRelaunchRequest: S.Schema<CreateDomainTaskRelaunchRequest>;
+export interface CreateDomainTaskRelaunchResponse {
+}
+export declare const CreateDomainTaskRelaunchResponse: S.Schema<CreateDomainTaskRelaunchResponse>;
+export interface CreateDomainUkOutgoingTransferRequest {
+    /** Service name */
+    serviceName: string;
+    /** Registrar tag */
+    tag: string;
+}
+export declare const CreateDomainUkOutgoingTransferRequest: S.Schema<CreateDomainUkOutgoingTransferRequest>;
+export interface CreateDomainZoneChangeContactRequest {
+    /** Zone name */
+    zoneName: string;
+    /** The contact to set as admin contact */
+    contactAdmin?: string;
+    /** The contact to set as billing contact */
+    contactBilling?: string;
+    /** The contact to set as tech contact */
+    contactTech?: string;
+}
+export declare const CreateDomainZoneChangeContactRequest: S.Schema<CreateDomainZoneChangeContactRequest>;
+export type CreateDomainZoneChangeContactResponseBodyList = Array<number>;
+export declare const CreateDomainZoneChangeContactResponseBodyList: S.Schema<CreateDomainZoneChangeContactResponseBodyList>;
+export type CreateDomainZoneChangeContactResponse = CreateDomainZoneChangeContactResponseBodyList;
+export declare const CreateDomainZoneChangeContactResponse: S.Schema<CreateDomainZoneChangeContactResponse>;
+export interface CreateDomainZoneTaskAccelerateRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const CreateDomainZoneTaskAccelerateRequest: S.Schema<CreateDomainZoneTaskAccelerateRequest>;
+export interface CreateDomainZoneTaskAccelerateResponse {
+}
+export declare const CreateDomainZoneTaskAccelerateResponse: S.Schema<CreateDomainZoneTaskAccelerateResponse>;
+export interface CreateDomainZoneTaskRelaunchRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const CreateDomainZoneTaskRelaunchRequest: S.Schema<CreateDomainZoneTaskRelaunchRequest>;
+export interface CreateDomainZoneTaskRelaunchResponse {
+}
+export declare const CreateDomainZoneTaskRelaunchResponse: S.Schema<CreateDomainZoneTaskRelaunchResponse>;
+export interface CreateDynDnsLoginRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Suffix that will be concatenated to the zoneName to create the login */
+    loginSuffix: string;
+    /** Password of the login */
+    password: string | Redacted.Redacted<string>;
+    /** Subdomain that the login will be allowed to update (use * to allow all) */
+    subDomain: string;
+}
+export declare const CreateDynDnsLoginRequest: S.Schema<CreateDynDnsLoginRequest>;
+/** DNS zone dynHost login */
+export interface DomainZoneDynHostLogin {
+    /** Login name */
+    login?: string;
+    /** Login sub-domain */
+    subDomain?: string;
+    /** Login zone */
+    zone?: string;
+}
+export declare const DomainZoneDynHostLogin: S.Schema<DomainZoneDynHostLogin>;
+export interface CreateDynDnsRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Record IP */
+    ip?: string;
+    /** Record sub-domain */
+    subDomain?: string | null;
+}
+export declare const CreateDynDnsRecordRequest: S.Schema<CreateDynDnsRecordRequest>;
+/** DNS zone dynHost record */
+export interface DomainZoneDynHostRecord {
+    /** Record ID */
+    id?: number;
+    /** Record IP */
+    ip?: string;
+    /** Record sub-domain */
+    subDomain?: string | null;
+    /** Record TTL (Time to Live) */
+    ttl?: number | null;
+    /** Record zone */
+    zone?: string;
+}
+export declare const DomainZoneDynHostRecord: S.Schema<DomainZoneDynHostRecord>;
+/** Resource record name */
+export type DomainZoneRecordTypeEnum = "A" | "AAAA" | "CAA" | "CNAME" | "DKIM" | "DMARC" | "DNAME" | "HTTPS" | "LOC" | "MX" | "NAPTR" | "NS" | "PTR" | "RP" | "SPF" | "SRV" | "SSHFP" | "SVCB" | "TLSA" | "TXT";
+export declare const DomainZoneRecordTypeEnum: any;
+export interface CreateRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    fieldType: DomainZoneRecordTypeEnum | (string & {});
+    /** Record subDomain */
+    subDomain?: string | null;
+    /** Target of the record */
+    target: string;
+    /** TTL of the record */
+    ttl?: number;
+}
+export declare const CreateRecordRequest: S.Schema<CreateRecordRequest>;
+/** DNS zone history */
+export interface DomainZoneRecord {
+    fieldType?: DomainZoneRecordTypeEnum;
+    /** Id of the record */
+    id?: number;
+    /** Record subDomain */
+    subDomain?: string | null;
+    /** Target of the record */
+    target?: string;
+    /** TTL of the record */
+    ttl?: number | null;
+    /** Resource record zone */
+    zone?: string;
+}
+export declare const DomainZoneRecord: S.Schema<DomainZoneRecord>;
+/** Redirection type: - visible -> Redirection by http code 302 - visiblePermanent -> Redirection by http code 301 - invisible -> Redirection by html frame */
+export type DomainZoneRedirectionTypeEnum = "invisible" | "visible" | "visiblePermanent";
+export declare const DomainZoneRedirectionTypeEnum: any;
+export interface CreateRedirectionRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Description for the invisible redirection */
+    description?: string | null;
+    /** Keywords for the invisible redirection */
+    keywords?: string | null;
+    /** Subdomain to redirect */
+    subDomain?: string;
+    /** Target of the redirection */
+    target: string;
+    /** Title for the invisible redirection */
+    title?: string | null;
+    type: DomainZoneRedirectionTypeEnum | (string & {});
+}
+export declare const CreateRedirectionRequest: S.Schema<CreateRedirectionRequest>;
+/** DNS zone redirections */
+export interface DomainZoneRedirection {
+    /** Description for the invisible redirection */
+    description?: string | null;
+    /** Id of the redirection */
+    id?: number;
+    /** Keywords for the invisible redirection */
+    keywords?: string | null;
+    /** Subdomain to redirect */
+    subDomain?: string | null;
+    /** Target of the redirection */
+    target?: string;
+    /** Title for the invisible redirection */
+    title?: string | null;
+    type?: DomainZoneRedirectionTypeEnum;
+    /** Redirection zone */
+    zone?: string;
+}
+export declare const DomainZoneRedirection: S.Schema<DomainZoneRedirection>;
+export interface DeleteDomainDataSmdRequest {
+    /** Smd ID */
+    smdId: string;
+}
+export declare const DeleteDomainDataSmdRequest: S.Schema<DeleteDomainDataSmdRequest>;
+export interface DeleteDomainDataSmdResponse {
+}
+export declare const DeleteDomainDataSmdResponse: S.Schema<DeleteDomainDataSmdResponse>;
+export interface DeleteDomainGlueRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Host */
+    host: string;
+}
+export declare const DeleteDomainGlueRecordRequest: S.Schema<DeleteDomainGlueRecordRequest>;
+export interface DeleteDomainNameServerRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const DeleteDomainNameServerRequest: S.Schema<DeleteDomainNameServerRequest>;
+/** All options a domain can have */
+export type DeleteDomainOptionRequestOption = "dnsAnycast";
+export declare const DeleteDomainOptionRequestOption: any;
+export interface DeleteDomainOptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Option */
+    option: DeleteDomainOptionRequestOption | (string & {});
+}
+export declare const DeleteDomainOptionRequest: S.Schema<DeleteDomainOptionRequest>;
+export interface DeleteDomainOptionResponse {
+}
+export declare const DeleteDomainOptionResponse: S.Schema<DeleteDomainOptionResponse>;
+export interface DeleteDynHostLoginRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Login */
+    login: string;
+}
+export declare const DeleteDynHostLoginRequest: S.Schema<DeleteDynHostLoginRequest>;
+export interface DeleteDynHostLoginResponse {
+}
+export declare const DeleteDynHostLoginResponse: S.Schema<DeleteDynHostLoginResponse>;
+export interface DeleteDynHostRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const DeleteDynHostRecordRequest: S.Schema<DeleteDynHostRecordRequest>;
+export interface DeleteDynHostRecordResponse {
+}
+export declare const DeleteDynHostRecordResponse: S.Schema<DeleteDynHostRecordResponse>;
+export interface DeleteRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const DeleteRecordRequest: S.Schema<DeleteRecordRequest>;
+export interface DeleteRecordResponse {
+}
+export declare const DeleteRecordResponse: S.Schema<DeleteRecordResponse>;
+export interface DeleteRedirectionRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const DeleteRedirectionRequest: S.Schema<DeleteRedirectionRequest>;
+export interface DeleteRedirectionResponse {
+}
+export declare const DeleteRedirectionResponse: S.Schema<DeleteRedirectionResponse>;
+export interface DisableDNSSECRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const DisableDNSSECRequest: S.Schema<DisableDNSSECRequest>;
+export interface DisableDNSSECResponse {
+}
+export declare const DisableDNSSECResponse: S.Schema<DisableDNSSECResponse>;
+/** DNS server type */
+export type DomainNameServerNameServerTypeEnum = "anycast" | "dedicated" | "empty" | "external" | "hold" | "hosted" | "hosting" | "mixed" | "parking";
+export declare const DomainNameServerNameServerTypeEnum: any;
+/** Domain lock status */
+export type DomainLockStatusEnum = "locked" | "locking" | "unavailable" | "unlocked" | "unlocking";
+export declare const DomainLockStatusEnum: any;
+export interface EditDomainRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name servers type */
+    nameServerType?: DomainNameServerNameServerTypeEnum | (string & {});
+    /** Current transfer lock status of the domain name */
+    transferLockStatus?: DomainLockStatusEnum | (string & {});
+}
+export declare const EditDomainRequest: S.Schema<EditDomainRequest>;
+/** A contact summary contains the personal data of a user */
+export interface DomainContactSummary {
+    /** Unique contact identifier (contact data can be edited via /me/contact/<ID>) */
+    id?: string;
+}
+export declare const DomainContactSummary: S.Schema<DomainContactSummary>;
+/** Domain dnssec state */
+export type DomainDnssecStateEnum = "disabled" | "enabled" | "not_supported";
+export declare const DomainDnssecStateEnum: any;
+/** Name server configuration */
+export interface DomainNameServerNameServer {
+    /** ID of the name server */
+    id?: number;
+    /** IPv4 adress of the name server */
+    ipv4?: string | null;
+    /** IPv6 adress of the name server */
+    ipv6?: string | null;
+    /** Name of the name server */
+    nameServer?: string;
+    /** Type of the name server */
+    nameServerType?: DomainNameServerNameServerTypeEnum;
+}
+export declare const DomainNameServerNameServer: S.Schema<DomainNameServerNameServer>;
+/** Name servers list */
+export type DomainDomainServiceNameServersList = Array<DomainNameServerNameServer>;
+export declare const DomainDomainServiceNameServersList: S.Schema<DomainDomainServiceNameServersList>;
+/** Offer */
+export type DomainOfferEnum = "diamond" | "gold" | "platinum";
+export declare const DomainOfferEnum: any;
+/** Parent service type enum */
+export type DomainParentServiceTypeEnum = "/allDom";
+export declare const DomainParentServiceTypeEnum: any;
+/** Parent service */
+export interface DomainParentService {
+    /** Name of the parent service */
+    name?: string;
+    /** Type of the parent service */
+    type?: DomainParentServiceTypeEnum;
+}
+export declare const DomainParentService: S.Schema<DomainParentService>;
+/** Domain renewal state */
+export type DomainRenewalStateEnum = "automatic_renew" | "cancellation_complete" | "cancellation_requested" | "manual_renew" | "unpaid";
+export declare const DomainRenewalStateEnum: any;
+/** Domain name current state */
+export type DomainDomainStateEnum = "autorenew_in_progress" | "autorenew_registry_in_progress" | "deleted" | "dispute" | "expired" | "ok" | "outgoing_transfer" | "pending_create" | "pending_delete" | "pending_incoming_transfer" | "pending_installation" | "registry_suspended" | "restorable" | "technical_suspended";
+export declare const DomainDomainStateEnum: any;
+/** Domain suspension state */
+export type DomainSuspensionStateEnum = "not_suspended" | "suspended";
+export declare const DomainSuspensionStateEnum: any;
+/** General information about a domain name service */
+export interface DomainDomainService {
+    /** Administrative contact data */
+    contactAdmin?: DomainContactSummary;
+    /** Billing contact data */
+    contactBilling?: DomainContactSummary;
+    /** Owner (registrant) contact data */
+    contactOwner?: DomainContactSummary;
+    /** Technical contact data */
+    contactTech?: DomainContactSummary;
+    /** Current DNSSEC state of the domain name */
+    dnssecState?: DomainDnssecStateEnum;
+    /** Whether DNSSEC is activated for this domain name */
+    dnssecSupported?: boolean;
+    /** Domain name */
+    domain?: string;
+    /** Date when the domain name will expire, if not renewed */
+    expirationDate?: string;
+    /** Whether the registry supports IPv6 glue records */
+    glueRecordIpv6Supported?: boolean;
+    /** Whether the registry supports multi-ip glue records */
+    glueRecordMultiIpSupported?: boolean;
+    /** Whether the registry supports hosts as independent entities */
+    hostSupported?: boolean;
+    /** Last update date */
+    lastUpdate?: string;
+    /** Name servers type */
+    nameServerType?: DomainNameServerNameServerTypeEnum;
+    /** Name servers list */
+    nameServers?: DomainDomainServiceNameServersList;
+    /** Offer associated with the domain name */
+    offer?: DomainOfferEnum;
+    /** Whether Whois data obfuscation is supported for this domain name */
+    owoSupported?: boolean;
+    /** Parent service */
+    parentService?: DomainParentService | null;
+    /** Date when the domain name should be renewed (relevant if renewalState is automatic_renew) */
+    renewalDate?: string;
+    /** Current renewal state of the domain name */
+    renewalState?: DomainRenewalStateEnum;
+    /** Technical service identifier */
+    serviceId?: number;
+    /** Current state of the domain name */
+    state?: DomainDomainStateEnum;
+    /** Current suspension state of the domain name */
+    suspensionState?: DomainSuspensionStateEnum;
+    /** Current transfer lock status of the domain name */
+    transferLockStatus?: DomainLockStatusEnum;
+    /** Owner (registrant) contact ID (contact data can be edited via /me/contact/<ID>) */
+    whoisOwner?: string;
+}
+export declare const DomainDomainService: S.Schema<DomainDomainService>;
+export interface EditDynDnsLoginRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Login */
+    login: string;
+    /** Login sub-domain */
+    subDomain?: string;
+}
+export declare const EditDynDnsLoginRequest: S.Schema<EditDynDnsLoginRequest>;
+export interface EditDynDnsLoginResponse {
+}
+export declare const EditDynDnsLoginResponse: S.Schema<EditDynDnsLoginResponse>;
+export interface EditDynDnsRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+    /** Record IP */
+    ip?: string;
+    /** Record sub-domain */
+    subDomain?: string | null;
+}
+export declare const EditDynDnsRecordRequest: S.Schema<EditDynDnsRecordRequest>;
+export interface EditDynDnsRecordResponse {
+}
+export declare const EditDynDnsRecordResponse: S.Schema<EditDynDnsRecordResponse>;
+export interface EditRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+    /** Record subdomain */
+    subDomain?: string | null;
+    /** Target of the record */
+    target?: string;
+    /** TTL of the record */
+    ttl?: number | null;
+}
+export declare const EditRecordRequest: S.Schema<EditRecordRequest>;
+export interface EditRecordResponse {
+}
+export declare const EditRecordResponse: S.Schema<EditRecordResponse>;
+export interface EditRedirectionRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+    /** Description for the invisible redirection */
+    description?: string | null;
+    /** Keywords for the invisible redirection */
+    keywords?: string | null;
+    /** Target of the redirection */
+    target?: string;
+    /** Title for the invisible redirection */
+    title?: string | null;
+    type?: DomainZoneRedirectionTypeEnum | (string & {});
+}
+export declare const EditRedirectionRequest: S.Schema<EditRedirectionRequest>;
+export interface EditRedirectionResponse {
+}
+export declare const EditRedirectionResponse: S.Schema<EditRedirectionResponse>;
+export interface EnableDNSSECRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const EnableDNSSECRequest: S.Schema<EnableDNSSECRequest>;
+export interface EnableDNSSECResponse {
+}
+export declare const EnableDNSSECResponse: S.Schema<EnableDNSSECResponse>;
+export interface GetContactRequest {
+    /** Contact ID */
+    contactId: number;
+}
+export declare const GetContactRequest: S.Schema<GetContactRequest>;
+export interface GetContactsRequest {
+}
+export declare const GetContactsRequest: S.Schema<GetContactsRequest>;
+export type GetContactsResponseBodyList = Array<DomainContact>;
+export declare const GetContactsResponseBodyList: S.Schema<GetContactsResponseBodyList>;
+export type GetContactsResponse = GetContactsResponseBodyList;
+export declare const GetContactsResponse: S.Schema<GetContactsResponse>;
+export interface GetDNSSECStatusRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const GetDNSSECStatusRequest: S.Schema<GetDNSSECStatusRequest>;
+/** All DNSSEC statuses */
+export type DomainDnssecStatusEnum = "disableInProgress" | "disabled" | "enableInProgress" | "enabled";
+export declare const DomainDnssecStatusEnum: any;
+/** DNS zone DNSSEC */
+export interface DomainZoneDnssec {
+    /** DNSSEC Status */
+    status?: DomainDnssecStatusEnum;
+}
+export declare const DomainZoneDnssec: S.Schema<DomainZoneDnssec>;
+export interface GetDomainRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDomainRequest: S.Schema<GetDomainRequest>;
+/** Resource state */
+export type IamResourceMetadataStateEnum = "EXPIRED" | "IN_CREATION" | "OK" | "SUSPENDED";
+export declare const IamResourceMetadataStateEnum: any;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamResourceMetadataTagsMap: S.Schema<IamResourceMetadataTagsMap>;
+/** IAM resource metadata embedded in services models */
+export interface IamResourceMetadata {
+    /** Resource display name */
+    displayName?: string | null;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Resource state */
+    state?: IamResourceMetadataStateEnum | null;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamResourceMetadataTagsMap | null;
+    /** Unique resource name used in policies */
+    urn?: string;
+}
+export declare const IamResourceMetadata: S.Schema<IamResourceMetadata>;
+/** Name servers list */
+export type DomainDomainServiceWithIAMNameServersList = Array<DomainNameServerNameServer>;
+export declare const DomainDomainServiceWithIAMNameServersList: S.Schema<DomainDomainServiceWithIAMNameServersList>;
+/** General information about a domain name service */
+export interface DomainDomainServiceWithIAM {
+    /** Administrative contact data */
+    contactAdmin?: DomainContactSummary;
+    /** Billing contact data */
+    contactBilling?: DomainContactSummary;
+    /** Owner (registrant) contact data */
+    contactOwner?: DomainContactSummary;
+    /** Technical contact data */
+    contactTech?: DomainContactSummary;
+    /** Current DNSSEC state of the domain name */
+    dnssecState?: DomainDnssecStateEnum;
+    /** Whether DNSSEC is activated for this domain name */
+    dnssecSupported?: boolean;
+    /** Domain name */
+    domain?: string;
+    /** Date when the domain name will expire, if not renewed */
+    expirationDate?: string;
+    /** Whether the registry supports IPv6 glue records */
+    glueRecordIpv6Supported?: boolean;
+    /** Whether the registry supports multi-ip glue records */
+    glueRecordMultiIpSupported?: boolean;
+    /** Whether the registry supports hosts as independent entities */
+    hostSupported?: boolean;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Last update date */
+    lastUpdate?: string;
+    /** Name servers type */
+    nameServerType?: DomainNameServerNameServerTypeEnum;
+    /** Name servers list */
+    nameServers?: DomainDomainServiceWithIAMNameServersList;
+    /** Offer associated with the domain name */
+    offer?: DomainOfferEnum;
+    /** Whether Whois data obfuscation is supported for this domain name */
+    owoSupported?: boolean;
+    /** Parent service */
+    parentService?: DomainParentService | null;
+    /** Date when the domain name should be renewed (relevant if renewalState is automatic_renew) */
+    renewalDate?: string;
+    /** Current renewal state of the domain name */
+    renewalState?: DomainRenewalStateEnum;
+    /** Technical service identifier */
+    serviceId?: number;
+    /** Current state of the domain name */
+    state?: DomainDomainStateEnum;
+    /** Current suspension state of the domain name */
+    suspensionState?: DomainSuspensionStateEnum;
+    /** Current transfer lock status of the domain name */
+    transferLockStatus?: DomainLockStatusEnum;
+    /** Owner (registrant) contact ID (contact data can be edited via /me/contact/<ID>) */
+    whoisOwner?: string;
+}
+export declare const DomainDomainServiceWithIAM: S.Schema<DomainDomainServiceWithIAM>;
+export interface GetDomainAuthInfoRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDomainAuthInfoRequest: S.Schema<GetDomainAuthInfoRequest>;
+export type GetDomainAuthInfoResponse = string;
+export declare const GetDomainAuthInfoResponse: S.Schema<GetDomainAuthInfoResponse>;
+export interface GetDomainConfigurationDataRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDomainConfigurationDataRequest: S.Schema<GetDomainConfigurationDataRequest>;
+/** Possible purposes of the domain */
+export type DomainIsForEnum = "campaign_website" | "educational_website" | "emails" | "information_website" | "other_purpose" | "redirect_page" | "transactional_website";
+export declare const DomainIsForEnum: any;
+/** Purposes of the domain */
+export type DomainConfigurationsCustomFieldsIsForList = Array<DomainIsForEnum>;
+export declare const DomainConfigurationsCustomFieldsIsForList: S.Schema<DomainConfigurationsCustomFieldsIsForList>;
+/** Representation of the domain custom fields */
+export interface DomainConfigurationsCustomFields {
+    /** Domain name audience */
+    audience?: string | null;
+    /** Auth Info */
+    authInfo?: string | null;
+    /** Purposes of the domain */
+    isFor?: DomainConfigurationsCustomFieldsIsForList | null;
+    /** Domain name other purpose */
+    otherPurpose?: string | null;
+    /** Reason of the purchase of this domain */
+    reason?: string | null;
+    /** Represented company */
+    represent?: string | null;
+}
+export declare const DomainConfigurationsCustomFields: S.Schema<DomainConfigurationsCustomFields>;
+export interface GetDomainConfigurationRuleRequest {
+    /** Depending on the action, the applied rule will change (transfer vs create) */
+    action: DomainActionEnum | (string & {});
+    /** The domain to get the configuration rule for */
+    domain: string;
+}
+export declare const GetDomainConfigurationRuleRequest: S.Schema<GetDomainConfigurationRuleRequest>;
+/** An "and" operator on multiple rules */
+export type DomainConfigurationRulesRuleAndList = Array<DomainConfigurationRulesRule>;
+export declare const DomainConfigurationRulesRuleAndList: S.Schema<DomainConfigurationRulesRuleAndList>;
+/** Used in rule to tell if rule (or part of the rule) is applicable for a given context */
+export type DomainConfigurationRulesContextEnum = "accept_conditions" | "claims" | "create" | "order" | "premium" | "protected_code" | "reason" | "trade" | "transfer" | "update";
+export declare const DomainConfigurationRulesContextEnum: any;
+/** The context on which the constraint applies */
+export type DomainConfigurationRulesConstraintContextsList = Array<DomainConfigurationRulesContextEnum>;
+export declare const DomainConfigurationRulesConstraintContextsList: S.Schema<DomainConfigurationRulesConstraintContextsList>;
+/** Operator use in configuration rule to check content of a field */
+export type DomainConfigurationRulesOperatorEnum = "between" | "contains" | "empty" | "eq" | "gt" | "gte" | "lt" | "lte" | "match" | "maxlength" | "minlength" | "ne" | "notcontains" | "notempty" | "readonly" | "required" | "shouldbetrue";
+export declare const DomainConfigurationRulesOperatorEnum: any;
+/** The values to match against */
+export type DomainConfigurationRulesConstraintValuesList = Array<string>;
+export declare const DomainConfigurationRulesConstraintValuesList: S.Schema<DomainConfigurationRulesConstraintValuesList>;
+/** A configuration rule defines validation to launch when executing an action on a domain (create, trade...). Depending on the extension, the rule may be different */
+export interface DomainConfigurationRulesConstraint {
+    /** Whether this constraint is applied or not */
+    conditions?: DomainConfigurationRulesRule | null;
+    /** The context on which the constraint applies */
+    contexts?: DomainConfigurationRulesConstraintContextsList | null;
+    /** The operator of the constraint */
+    operator?: DomainConfigurationRulesOperatorEnum | null;
+    /** The value to match against */
+    value?: string | null;
+    /** The values to match against */
+    values?: DomainConfigurationRulesConstraintValuesList | null;
+}
+export declare const DomainConfigurationRulesConstraint: S.Schema<DomainConfigurationRulesConstraint>;
+/** The constraints of the rule */
+export type DomainConfigurationRulesRuleConstraintsList = Array<DomainConfigurationRulesConstraint>;
+export declare const DomainConfigurationRulesRuleConstraintsList: S.Schema<DomainConfigurationRulesRuleConstraintsList>;
+/** The context on which the rule applies */
+export type DomainConfigurationRulesRuleContextsList = Array<DomainConfigurationRulesContextEnum>;
+export declare const DomainConfigurationRulesRuleContextsList: S.Schema<DomainConfigurationRulesRuleContextsList>;
+/** An "or" operator on multiple rules */
+export type DomainConfigurationRulesRuleOrList = Array<DomainConfigurationRulesRule>;
+export declare const DomainConfigurationRulesRuleOrList: S.Schema<DomainConfigurationRulesRuleOrList>;
+/** Type of rule configuration */
+export type DomainConfigurationRulesTypeEnum = "bool" | "contact" | "date_ISO8601" | "domain" | "json" | "number" | "string" | "string[]" | "text";
+export declare const DomainConfigurationRulesTypeEnum: any;
+/** A configuration rule defines validation to launch when executing an action on a domain (create, trade...). Depending on the extension, the rule may be different */
+export interface DomainConfigurationRulesRule {
+    /** An "and" operator on multiple rules */
+    and?: DomainConfigurationRulesRuleAndList | null;
+    /** Whether this rule is applied or not */
+    conditions?: DomainConfigurationRulesRule | null;
+    /** The constraints of the rule */
+    constraints?: DomainConfigurationRulesRuleConstraintsList | null;
+    /** The context on which the rule applies */
+    contexts?: DomainConfigurationRulesRuleContextsList | null;
+    /** The description of the rule */
+    description?: string | null;
+    /** The fields with specific rules */
+    fields?: DomainConfigurationRulesRule | null;
+    /** The label of the rule */
+    label?: string | null;
+    /** An "or" operator on multiple rules */
+    or?: DomainConfigurationRulesRuleOrList | null;
+    /** The default value used for the rule */
+    placeholder?: string | null;
+    /** The type of the object the rule applies on */
+    type?: DomainConfigurationRulesTypeEnum | null;
+}
+export declare const DomainConfigurationRulesRule: S.Schema<DomainConfigurationRulesRule>;
+export interface GetDomainDataClaimNoticeRequest {
+    /** Domain name */
+    domain: string;
+}
+export declare const GetDomainDataClaimNoticeRequest: S.Schema<GetDomainDataClaimNoticeRequest>;
+/** Definition of a trademark claim notice classification */
+export interface DomainDataClaimNoticeClassification {
+    /** Summary of the classification */
+    description?: string;
+    /** Code of the classification */
+    number?: string;
+}
+export declare const DomainDataClaimNoticeClassification: S.Schema<DomainDataClaimNoticeClassification>;
+/** Classifications where trademark claim notice apply */
+export type DomainDataClaimNoticeClaimNoticeDecisionClassificationsList = Array<DomainDataClaimNoticeClassification>;
+export declare const DomainDataClaimNoticeClaimNoticeDecisionClassificationsList: S.Schema<DomainDataClaimNoticeClaimNoticeDecisionClassificationsList>;
+/** Regions where court decision apply */
+export type DomainDataClaimNoticeCourtDecisionRegionsList = Array<string>;
+export declare const DomainDataClaimNoticeCourtDecisionRegionsList: S.Schema<DomainDataClaimNoticeCourtDecisionRegionsList>;
+/** Definition of a court decision */
+export interface DomainDataClaimNoticeCourtDecision {
+    /** Country code */
+    countryCode?: string;
+    /** Court name */
+    courtName?: string;
+    /** Reference number of court decision */
+    referenceNumber?: string;
+    /** Regions where court decision apply */
+    regions?: DomainDataClaimNoticeCourtDecisionRegionsList;
+}
+export declare const DomainDataClaimNoticeCourtDecision: S.Schema<DomainDataClaimNoticeCourtDecision>;
+/** Array of court decisions related to claim notice */
+export type DomainDataClaimNoticeClaimNoticeDecisionCourtDecisionsList = Array<DomainDataClaimNoticeCourtDecision>;
+export declare const DomainDataClaimNoticeClaimNoticeDecisionCourtDecisionsList: S.Schema<DomainDataClaimNoticeClaimNoticeDecisionCourtDecisionsList>;
+/** Array of street name */
+export type DomainDataClaimNoticeAddressStreetsList = Array<string>;
+export declare const DomainDataClaimNoticeAddressStreetsList: S.Schema<DomainDataClaimNoticeAddressStreetsList>;
+/** Address for a claim notice holder */
+export interface DomainDataClaimNoticeAddress {
+    /** City */
+    city?: string | null;
+    /** Country code */
+    countryCode?: NichandleCountryEnum | null;
+    /** Fax number */
+    fax?: string | null;
+    /** Fax number extension */
+    faxExtension?: string | null;
+    /** Postal zip code */
+    postalCode?: string | null;
+    /** State of province */
+    stateOrProvince?: string | null;
+    /** Array of street name */
+    streets?: DomainDataClaimNoticeAddressStreetsList;
+    /** Phone number */
+    voice?: string | null;
+    /** Phone number extension */
+    voiceExtension?: string | null;
+}
+export declare const DomainDataClaimNoticeAddress: S.Schema<DomainDataClaimNoticeAddress>;
+/** Contact definition of a claim notice holder */
+export interface DomainDataClaimNoticeContact {
+    /** Address of holder */
+    address?: DomainDataClaimNoticeAddress;
+    /** Email address */
+    email?: string | null;
+    /** Legitimacy of holder */
+    entitlement?: string | null;
+    /** Name of claim notice holder */
+    name?: string | null;
+    /** Organisation name */
+    organisation?: string | null;
+    /** Type of contact */
+    type?: string | null;
+}
+export declare const DomainDataClaimNoticeContact: S.Schema<DomainDataClaimNoticeContact>;
+/** Trademark contacts */
+export type DomainDataClaimNoticeClaimNoticeDecisionTrademarkContactsList = Array<DomainDataClaimNoticeContact>;
+export declare const DomainDataClaimNoticeClaimNoticeDecisionTrademarkContactsList: S.Schema<DomainDataClaimNoticeClaimNoticeDecisionTrademarkContactsList>;
+/** Trademark holders */
+export type DomainDataClaimNoticeClaimNoticeDecisionTrademarkHoldersList = Array<DomainDataClaimNoticeContact>;
+export declare const DomainDataClaimNoticeClaimNoticeDecisionTrademarkHoldersList: S.Schema<DomainDataClaimNoticeClaimNoticeDecisionTrademarkHoldersList>;
+/** Definition of a UDRP procedure */
+export interface DomainDataClaimNoticeUDRP {
+    /** Case number */
+    caseNumber?: string;
+    /** UDRP Provider */
+    udrpProvider?: string;
+}
+export declare const DomainDataClaimNoticeUDRP: S.Schema<DomainDataClaimNoticeUDRP>;
+/** Trademark UDRP information */
+export type DomainDataClaimNoticeClaimNoticeDecisionTrademarkUDRPList = Array<DomainDataClaimNoticeUDRP>;
+export declare const DomainDataClaimNoticeClaimNoticeDecisionTrademarkUDRPList: S.Schema<DomainDataClaimNoticeClaimNoticeDecisionTrademarkUDRPList>;
+/** Definition of a single claim notice */
+export interface DomainDataClaimNoticeClaimNoticeDecision {
+    /** Classifications where trademark claim notice apply */
+    classifications?: DomainDataClaimNoticeClaimNoticeDecisionClassificationsList;
+    /** Array of court decisions related to claim notice */
+    courtDecisions?: DomainDataClaimNoticeClaimNoticeDecisionCourtDecisionsList;
+    /** Goods and services on which apply claim notice */
+    goodsAndServices?: string;
+    /** Name of jurisdiction */
+    jurisdiction?: string;
+    /** Jurisdiction country code */
+    jurisdictionCountryCode?: string;
+    /** Mark name implicated in claim notice */
+    markName?: string;
+    /** Trademark contacts */
+    trademarkContacts?: DomainDataClaimNoticeClaimNoticeDecisionTrademarkContactsList;
+    /** Trademark holders */
+    trademarkHolders?: DomainDataClaimNoticeClaimNoticeDecisionTrademarkHoldersList;
+    /** Trademark UDRP information */
+    trademarkUDRP?: DomainDataClaimNoticeClaimNoticeDecisionTrademarkUDRPList;
+}
+export declare const DomainDataClaimNoticeClaimNoticeDecision: S.Schema<DomainDataClaimNoticeClaimNoticeDecision>;
+/** Array of claim notice for the domain */
+export type DomainDataClaimNoticeClaimNoticeClaimsList = Array<DomainDataClaimNoticeClaimNoticeDecision>;
+export declare const DomainDataClaimNoticeClaimNoticeClaimsList: S.Schema<DomainDataClaimNoticeClaimNoticeClaimsList>;
+/** Type of claim notice */
+export type DomainDataClaimNoticeClaimNoticeTypeEnum = "TRADEMARK" | "UK";
+export declare const DomainDataClaimNoticeClaimNoticeTypeEnum: any;
+/** Definition of claim notices applying to a domain name */
+export interface DomainDataClaimNoticeClaimNotice {
+    /** Array of claim notice for the domain */
+    claims?: DomainDataClaimNoticeClaimNoticeClaimsList | null;
+    /** Ending date of claim notice */
+    endingDate?: string;
+    /** Claim notice ID */
+    id?: string;
+    /** Label referring to claim notice */
+    label?: string;
+    /** Beginning date of claim notice */
+    startingDate?: string | null;
+    /** Type of claim notice */
+    type?: DomainDataClaimNoticeClaimNoticeTypeEnum | null;
+}
+export declare const DomainDataClaimNoticeClaimNotice: S.Schema<DomainDataClaimNoticeClaimNotice>;
+export interface GetDomainDataSmdRequest {
+    /** Smd ID */
+    smdId: string;
+}
+export declare const GetDomainDataSmdRequest: S.Schema<GetDomainDataSmdRequest>;
+export interface GetDomainDsRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetDomainDsRecordRequest: S.Schema<GetDomainDsRecordRequest>;
+/** Generated: The key has been created, but has not yet been used for anything. Published: The DNSKEY record is published in the zone, but predecessors of the key may be held in caches. Ready: The new key data has been published for long enough to guarantee that any previous versions of the DNSKEY RRset have expired from caches. Active: The key has started to be used to sign RRsets. Retired: A successor key has become active and this key is no longer being used to generate RRSIGs. Removed: The key has been removed from the zone. Revoked: The key is published for a period with the "revoke" bit set as a way of notifying validating resolvers that have configured it as an trust anchor that it is about to be removed from the zone. */
+export type DnssecKeyStatusEnum = "active" | "generated" | "published" | "removed" | "retired" | "revoked";
+export declare const DnssecKeyStatusEnum: any;
+/** Domain's DNSSEC Key */
+export interface DnssecKey {
+    /** Algorithm number of the DNSSEC key */
+    algorithm?: DnssecKeyAlgorithmEnum;
+    /** Flag of the DNSSEC key */
+    flags?: DnssecKeyFlagEnum;
+    /** ID of the DNSSEC key */
+    id?: number;
+    /** Public key */
+    publicKey?: string;
+    /** Key status of the DNSSEC key */
+    status?: DnssecKeyStatusEnum;
+    /** Tag of the DNSSEC key */
+    tag?: number;
+}
+export declare const DnssecKey: S.Schema<DnssecKey>;
+export interface GetDomainExtensionRequest {
+    /** Name */
+    name: string;
+}
+export declare const GetDomainExtensionRequest: S.Schema<GetDomainExtensionRequest>;
+/** A domain name extension */
+export interface DomainExtensionsExtension {
+    /** The extension name */
+    name?: string;
+}
+export declare const DomainExtensionsExtension: S.Schema<DomainExtensionsExtension>;
+export interface GetDomainExtensionRegistryConfigurationsRequest {
+    /** Name */
+    name: string;
+}
+export declare const GetDomainExtensionRegistryConfigurationsRequest: S.Schema<GetDomainExtensionRegistryConfigurationsRequest>;
+/** The registry configurations applied to the DNS of a domain name */
+export interface DomainExtensionsRegistryConfigurationsDNSRegistryConfiguration {
+    /** Whether DNSSEC is supported by the registry/backend and handled by OVHcloud */
+    isDNSSECSupported?: boolean;
+    /** The maximum required number of DNS */
+    maxNumber?: number | null;
+    /** The minimum required number of DNS */
+    minNumber?: number | null;
+}
+export declare const DomainExtensionsRegistryConfigurationsDNSRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsDNSRegistryConfiguration>;
+/** The type of an extension (country-code TLD or generic TLD) */
+export type DomainExtensionsRegistryConfigurationsExtensionTypeEnum = "cctld" | "gtld";
+export declare const DomainExtensionsRegistryConfigurationsExtensionTypeEnum: any;
+/** The registry configurations applied to the domain name label */
+export interface DomainExtensionsRegistryConfigurationsLabelDomainRegistryConfiguration {
+    /** Whether International Domain Names are supported by the registry and handled by OVHcloud */
+    isIDNSupported?: boolean;
+    /** The maximum length allowed for a domain name (without the extension) */
+    maxLength?: number | null;
+    /** The minimum length allowed for a domain name (without the extension) */
+    minLength?: number | null;
+}
+export declare const DomainExtensionsRegistryConfigurationsLabelDomainRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsLabelDomainRegistryConfiguration>;
+/** The registry configurations applied to a domain name */
+export interface DomainExtensionsRegistryConfigurationsDomainRegistryConfiguration {
+    /** The type of an extension (cctld or gtld) */
+    extension_type?: DomainExtensionsRegistryConfigurationsExtensionTypeEnum;
+    /** Whether premium domains are supported by the registry and handled by OVHcloud */
+    isPremiumSupported?: boolean;
+    /** The registry configurations applied to the domain name label */
+    label?: DomainExtensionsRegistryConfigurationsLabelDomainRegistryConfiguration;
+}
+export declare const DomainExtensionsRegistryConfigurationsDomainRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsDomainRegistryConfiguration>;
+/** The number of months allowed for a domain creation */
+export type DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfigurationAllowedPeriodsInMonthsList = Array<number>;
+export declare const DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfigurationAllowedPeriodsInMonthsList: S.Schema<DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfigurationAllowedPeriodsInMonthsList>;
+/** The registry configurations applied when creating a domain name */
+export interface DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfiguration {
+    /** The number of months allowed for a domain creation */
+    allowedPeriodsInMonths?: DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfigurationAllowedPeriodsInMonthsList | null;
+}
+export declare const DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfiguration>;
+/** The registry configurations applied when ordering a domain name */
+export interface DomainExtensionsRegistryConfigurationsOrderLifecycleRegistryConfiguration {
+    /** True if the extension can be ordered from the website */
+    active?: boolean;
+    /** The maximum number of months a domain can be ordered for */
+    maxMonths?: number | null;
+    /** The minimum number of months a domain can be ordered for */
+    minMonths?: number | null;
+}
+export declare const DomainExtensionsRegistryConfigurationsOrderLifecycleRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsOrderLifecycleRegistryConfiguration>;
+/** The number of months allowed for a domain renewal */
+export type DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfigurationAllowedPeriodsInMonthsList = Array<number>;
+export declare const DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfigurationAllowedPeriodsInMonthsList: S.Schema<DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfigurationAllowedPeriodsInMonthsList>;
+/** The registry configurations applied when renewing a domain name */
+export interface DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfiguration {
+    /** The number of months allowed for a domain renewal */
+    allowedPeriodsInMonths?: DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfigurationAllowedPeriodsInMonthsList | null;
+    /** The number of calendar days between the expiration date and the redemption period when a renew can be executed. During this period, the domain has expired and is suspended. It's the number of days before real deletion. The customer can still renew. */
+    gracePeriodInDays?: number | null;
+}
+export declare const DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfiguration>;
+/** The registry configurations applied when restoring a domain name */
+export interface DomainExtensionsRegistryConfigurationsRestoreLifecycleRegistryConfiguration {
+    /** The number of calendar days in which the customer still can restore their domain after expiration. During this period, the domain has been deleted. The customer can still restore it until these days are over. Then the domain is returned to public, if not restored. */
+    gracePeriodInDays?: number | null;
+}
+export declare const DomainExtensionsRegistryConfigurationsRestoreLifecycleRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsRestoreLifecycleRegistryConfiguration>;
+/** The number of months allowed for a domain transfer */
+export type DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfigurationAllowedPeriodsInMonthsList = Array<number>;
+export declare const DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfigurationAllowedPeriodsInMonthsList: S.Schema<DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfigurationAllowedPeriodsInMonthsList>;
+/** The registry configurations applied when transfering a domain name */
+export interface DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfiguration {
+    /** The number of months allowed for a domain transfer */
+    allowedPeriodsInMonths?: DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfigurationAllowedPeriodsInMonthsList | null;
+    /** Whether the transfer includes a renewal of the domain name, and therefore updates its expiration date */
+    includeRenew?: boolean;
+}
+export declare const DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfiguration>;
+/** The registry configurations of the lifecycle of a domain name */
+export interface DomainExtensionsRegistryConfigurationsLifecycleRegistryConfiguration {
+    /** The registry configurations applied when creating a domain name */
+    create?: DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfiguration;
+    /** The registry configurations applied when ordering a domain name */
+    order?: DomainExtensionsRegistryConfigurationsOrderLifecycleRegistryConfiguration;
+    /** The registry configurations applied when renewing a domain name */
+    renew?: DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfiguration;
+    /** The registry configurations applied when restoring a domain name */
+    restore?: DomainExtensionsRegistryConfigurationsRestoreLifecycleRegistryConfiguration;
+    /** The registry configurations applied when transfering a domain name */
+    transfer?: DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfiguration;
+}
+export declare const DomainExtensionsRegistryConfigurationsLifecycleRegistryConfiguration: S.Schema<DomainExtensionsRegistryConfigurationsLifecycleRegistryConfiguration>;
+/** The registry configurations applied to a domain extension (TLD, SLD) */
+export interface DomainExtensionsRegistryConfigurationsRegistryConfigurations {
+    /** Configurations on the DNS associated to the domain for the given extension */
+    dns?: DomainExtensionsRegistryConfigurationsDNSRegistryConfiguration;
+    /** Configurations on the domain name itself for the given extension */
+    domain?: DomainExtensionsRegistryConfigurationsDomainRegistryConfiguration;
+    /** Configurations on the lifecycle of a domain for the given extension */
+    lifecycle?: DomainExtensionsRegistryConfigurationsLifecycleRegistryConfiguration;
+}
+export declare const DomainExtensionsRegistryConfigurationsRegistryConfigurations: S.Schema<DomainExtensionsRegistryConfigurationsRegistryConfigurations>;
+export interface GetDomainGlueRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Host */
+    host: string;
+}
+export declare const GetDomainGlueRecordRequest: S.Schema<GetDomainGlueRecordRequest>;
+/** IP address */
+export type DomainGlueRecordGlueRecordIpsList = Array<string>;
+export declare const DomainGlueRecordGlueRecordIpsList: S.Schema<DomainGlueRecordGlueRecordIpsList>;
+/** Glue record */
+export interface DomainGlueRecordGlueRecord {
+    /** Host of the glue record */
+    host?: string;
+    /** IP address */
+    ips: DomainGlueRecordGlueRecordIpsList;
+}
+export declare const DomainGlueRecordGlueRecord: S.Schema<DomainGlueRecordGlueRecord>;
+export interface GetDomainNameServerRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetDomainNameServerRequest: S.Schema<GetDomainNameServerRequest>;
+/** Full name server configuration */
+export interface DomainNameServerFullNameServer {
+    /** Host of the name server */
+    host?: string;
+    /** ID of the name server */
+    id?: number;
+    /** IP address of the name server */
+    ip?: string | null;
+    /** isUsed flag of the name server */
+    isUsed?: boolean;
+    /** toDelete flag of the name server */
+    toDelete?: boolean;
+}
+export declare const DomainNameServerFullNameServer: S.Schema<DomainNameServerFullNameServer>;
+export interface GetDomainNameServerStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetDomainNameServerStatusRequest: S.Schema<GetDomainNameServerStatusRequest>;
+/** DNS server state */
+export type DomainNameServerNameServerStateEnum = "ko" | "ok";
+export declare const DomainNameServerNameServerStateEnum: any;
+/** DNS server status */
+export interface DomainNameServerNameServerStatus {
+    /** Whether or not the DNS server is working */
+    state?: DomainNameServerNameServerStateEnum;
+    /** Whether or not the DNS server is managed by OVHcloud */
+    type?: DomainNameServerNameServerTypeEnum;
+    /** Date from which the DNS server is used by the domain */
+    usedSince?: string | null;
+}
+export declare const DomainNameServerNameServerStatus: S.Schema<DomainNameServerNameServerStatus>;
+/** All options a domain can have */
+export type GetDomainOptionRequestOption = "dnsAnycast";
+export declare const GetDomainOptionRequestOption: any;
+export interface GetDomainOptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Option */
+    option: GetDomainOptionRequestOption | (string & {});
+}
+export declare const GetDomainOptionRequest: S.Schema<GetDomainOptionRequest>;
+/** All options a domain can have */
+export type DomainDomainOptionEnum = "dnsAnycast";
+export declare const DomainDomainOptionEnum: any;
+/** All states a domain Option can be in */
+export type DomainDomainOptionStateEnum = "released" | "subscribed";
+export declare const DomainDomainOptionStateEnum: any;
+/** Information about the options of a domain */
+export interface DomainOption {
+    /** Expiration date of the option */
+    expirationDate?: string;
+    /** The option name */
+    option?: DomainDomainOptionEnum;
+    /** The state of the option */
+    state?: DomainDomainOptionStateEnum;
+}
+export declare const DomainOption: S.Schema<DomainOption>;
+export interface GetDomainOptionsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDomainOptionsRequest: S.Schema<GetDomainOptionsRequest>;
+/** Data of a domain option */
+export interface DomainServiceOption {
+    /** Service name of the option */
+    serviceName?: string;
+}
+export declare const DomainServiceOption: S.Schema<DomainServiceOption>;
+/** Representation of the domain options */
+export interface DomainServiceOptions {
+    /** Hosting option */
+    hosting?: DomainServiceOption | null;
+    /** Offer option (Diamond, Platinum) */
+    offer?: DomainServiceOption | null;
+    /** DNS zone option */
+    zone?: DomainServiceOption | null;
+}
+export declare const DomainServiceOptions: S.Schema<DomainServiceOptions>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type GetDomainsRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const GetDomainsRequestIamTagsValueList: S.Schema<GetDomainsRequestIamTagsValueList>;
+export type GetDomainsRequestIamTagsMap = {
+    [key: string]: GetDomainsRequestIamTagsValueList | undefined;
+};
+export declare const GetDomainsRequestIamTagsMap: S.Schema<GetDomainsRequestIamTagsMap>;
+export interface GetDomainsRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: GetDomainsRequestIamTagsMap;
+    /** Filter domain names by owner ID */
+    whoisOwner?: string;
+}
+export declare const GetDomainsRequest: S.Schema<GetDomainsRequest>;
+export type GetDomainsResponseBodyList = Array<string>;
+export declare const GetDomainsResponseBodyList: S.Schema<GetDomainsResponseBodyList>;
+export type GetDomainsResponse = GetDomainsResponseBodyList;
+export declare const GetDomainsResponse: S.Schema<GetDomainsResponse>;
+export interface GetDomainServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDomainServiceInfosRequest: S.Schema<GetDomainServiceInfosRequest>;
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export declare const ServicesServicePossibleRenewPeriodList: S.Schema<ServicesServicePossibleRenewPeriodList>;
+/** Map a possible renew for a specific service */
+export interface ServiceRenewType {
+    /** The service is automatically renewed */
+    automatic?: boolean;
+    /** The service will be deleted at expiration */
+    deleteAtExpiration?: boolean;
+    /** The service forced to be renewed */
+    forced?: boolean;
+    /** The service needs to be manually renewed and paid */
+    manualPayment?: boolean | null;
+    /** period of renew in month */
+    period?: number | null;
+}
+export declare const ServiceRenewType: S.Schema<ServiceRenewType>;
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum = "automaticForcedProduct" | "automaticV2012" | "automaticV2014" | "automaticV2016" | "manual" | "oneShot" | "option";
+export declare const ServiceRenewalTypeEnum: any;
+/** service.StateEnum */
+export type ServiceStateEnum = "autorenewInProgress" | "expired" | "inCreation" | "ok" | "pendingDebt" | "unPaid";
+export declare const ServiceStateEnum: any;
+/** Details about a Service */
+export interface ServicesService {
+    /** Indicates that the service can be set up to be deleted at expiration */
+    canDeleteAtExpiration?: boolean;
+    contactAdmin?: string;
+    contactBilling?: string;
+    contactTech?: string;
+    creation?: string;
+    domain?: string;
+    engagedUpTo?: string | null;
+    expiration?: string;
+    /** All the possible renew period of your service in month */
+    possibleRenewPeriod?: ServicesServicePossibleRenewPeriodList | null;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+    renewalType?: ServiceRenewalTypeEnum;
+    serviceId?: number;
+    status?: ServiceStateEnum;
+}
+export declare const ServicesService: S.Schema<ServicesService>;
+export interface GetDomainTaskRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetDomainTaskRequest: S.Schema<GetDomainTaskRequest>;
+export interface GetDomainZoneCapabilitiesRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const GetDomainZoneCapabilitiesRequest: S.Schema<GetDomainZoneCapabilitiesRequest>;
+/** DNS zone capabilities */
+export interface DomainZoneCapabilities {
+    /** True if dynHost available for this zone */
+    dynHost?: boolean;
+}
+export declare const DomainZoneCapabilities: S.Schema<DomainZoneCapabilities>;
+export interface GetDomainZoneExportRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const GetDomainZoneExportRequest: S.Schema<GetDomainZoneExportRequest>;
+export type GetDomainZoneExportResponse = string;
+export declare const GetDomainZoneExportResponse: S.Schema<GetDomainZoneExportResponse>;
+export interface GetDomainZoneHistoryRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Creation date */
+    creationDate: string;
+}
+export declare const GetDomainZoneHistoryRequest: S.Schema<GetDomainZoneHistoryRequest>;
+/** DNS zone history */
+export interface DomainZoneZoneRestorePoint {
+    /** The date of backup creation */
+    creationDate?: string;
+    /** The URL of the saved zone at this date */
+    zoneFileUrl?: string;
+}
+export declare const DomainZoneZoneRestorePoint: S.Schema<DomainZoneZoneRestorePoint>;
+export interface GetDomainZoneOptionRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Name */
+    name: string;
+}
+export declare const GetDomainZoneOptionRequest: S.Schema<GetDomainZoneOptionRequest>;
+/** DNS zone option */
+export interface DomainZoneOption {
+    /** The option name */
+    name?: string;
+}
+export declare const DomainZoneOption: S.Schema<DomainZoneOption>;
+export interface GetDomainZoneOptionServiceInfosRequest {
+    /** The internal name of your zone */
+    zoneName: string;
+    /** The option name */
+    name: string;
+}
+export declare const GetDomainZoneOptionServiceInfosRequest: S.Schema<GetDomainZoneOptionServiceInfosRequest>;
+export interface GetDomainZoneServiceInfosRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const GetDomainZoneServiceInfosRequest: S.Schema<GetDomainZoneServiceInfosRequest>;
+export interface GetDomainZoneSoaRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const GetDomainZoneSoaRequest: S.Schema<GetDomainZoneSoaRequest>;
+/** DNS zone SOA */
+export interface DomainZoneSoa {
+    /** Email address of the DNS Administrator */
+    email?: string;
+    /** When a zone transfer fails, a countdown clock begins. When the number of seconds set in the expire field elapses, the nameserver stops answering for that zone file */
+    expire?: number;
+    /** Non-Existent Domain TTL, if the name server returns a negative response, the remote server should wait the number of seconds set in the nxDomainTtl field before trying again */
+    nxDomainTtl?: number;
+    /** The refresh value determines the interval in seconds between successful zone transfers of the entire zone file from a nameserver to another. */
+    refresh?: number;
+    /** The serial number is used to indicate which copy of the zone file is the most current. When editing zone files, you must increment the serial number */
+    serial?: number;
+    /** Primary authoritative server */
+    server?: string;
+    /** Time To Live in seconds */
+    ttl?: number;
+}
+export declare const DomainZoneSoa: S.Schema<DomainZoneSoa>;
+export interface GetDomainZoneTaskRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetDomainZoneTaskRequest: S.Schema<GetDomainZoneTaskRequest>;
+/** All functions from a dns task */
+export type DomainTaskFunctionEnum = "DnsAnycastActivate" | "DnsAnycastDeactivate" | "DnssecDisable" | "DnssecEnable" | "DnssecResigning" | "DnssecRollKsk" | "DnssecRollZsk" | "ZoneCheck" | "ZoneCreate" | "ZoneCut" | "ZoneDelete" | "ZoneImport" | "ZoneRefresh" | "ZoneRestore";
+export declare const DomainTaskFunctionEnum: any;
+/** All statuses from a dns task */
+export type DomainTaskStatusEnum = "cancelled" | "doing" | "done" | "error" | "problem" | "todo";
+export declare const DomainTaskStatusEnum: any;
+/** DNS zone task */
+export interface DomainZoneTask {
+    /** Can accelerate the task */
+    canAccelerate?: boolean;
+    /** Can cancel the task */
+    canCancel?: boolean;
+    /** Can relaunch the task */
+    canRelaunch?: boolean;
+    /** Comment about the task */
+    comment?: string | null;
+    /** Creation date of the task */
+    creationDate?: string;
+    /** Done date of the task */
+    doneDate?: string | null;
+    /** Function of the task */
+    function?: DomainTaskFunctionEnum;
+    /** Id of the task */
+    id?: number;
+    /** Last update date of the task */
+    lastUpdate?: string | null;
+    /** Status of the task */
+    status?: DomainTaskStatusEnum;
+    /** Todo date of the task */
+    todoDate?: string;
+}
+export declare const DomainZoneTask: S.Schema<DomainZoneTask>;
+export interface GetDynHostLoginRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Login */
+    login: string;
+}
+export declare const GetDynHostLoginRequest: S.Schema<GetDynHostLoginRequest>;
+export interface GetDynHostLoginsRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Filter the value of login property (ilike) */
+    login?: string;
+    /** Filter the value of subDomain property (ilike) */
+    subDomain?: string;
+}
+export declare const GetDynHostLoginsRequest: S.Schema<GetDynHostLoginsRequest>;
+export type GetDynHostLoginsResponseBodyList = Array<string>;
+export declare const GetDynHostLoginsResponseBodyList: S.Schema<GetDynHostLoginsResponseBodyList>;
+export type GetDynHostLoginsResponse = GetDynHostLoginsResponseBodyList;
+export declare const GetDynHostLoginsResponse: S.Schema<GetDynHostLoginsResponse>;
+export interface GetDynHostRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetDynHostRecordRequest: S.Schema<GetDynHostRecordRequest>;
+export interface GetDynHostRecordsRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Filter the value of subDomain property (ilike) */
+    subDomain?: string;
+}
+export declare const GetDynHostRecordsRequest: S.Schema<GetDynHostRecordsRequest>;
+export type GetDynHostRecordsResponseBodyList = Array<number>;
+export declare const GetDynHostRecordsResponseBodyList: S.Schema<GetDynHostRecordsResponseBodyList>;
+export type GetDynHostRecordsResponse = GetDynHostRecordsResponseBodyList;
+export declare const GetDynHostRecordsResponse: S.Schema<GetDynHostRecordsResponse>;
+export interface GetRecordRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetRecordRequest: S.Schema<GetRecordRequest>;
+export interface GetRecordsRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Filter the value of fieldType property (like) */
+    fieldType?: DomainZoneRecordTypeEnum | (string & {});
+    /** Filter the value of subDomain property (ilike) */
+    subDomain?: string;
+}
+export declare const GetRecordsRequest: S.Schema<GetRecordsRequest>;
+export type GetRecordsResponseBodyList = Array<number>;
+export declare const GetRecordsResponseBodyList: S.Schema<GetRecordsResponseBodyList>;
+export type GetRecordsResponse = GetRecordsResponseBodyList;
+export declare const GetRecordsResponse: S.Schema<GetRecordsResponse>;
+export interface GetRedirectionRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetRedirectionRequest: S.Schema<GetRedirectionRequest>;
+export interface GetRedirectionsRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Filter the value of subDomain property */
+    subDomain?: string;
+}
+export declare const GetRedirectionsRequest: S.Schema<GetRedirectionsRequest>;
+export type GetRedirectionsResponseBodyList = Array<number>;
+export declare const GetRedirectionsResponseBodyList: S.Schema<GetRedirectionsResponseBodyList>;
+export type GetRedirectionsResponse = GetRedirectionsResponseBodyList;
+export declare const GetRedirectionsResponse: S.Schema<GetRedirectionsResponse>;
+export interface GetZoneRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const GetZoneRequest: S.Schema<GetZoneRequest>;
+/** Name servers that host the DNS zone */
+export type DomainZoneWithIAMNameServersList = Array<string>;
+export declare const DomainZoneWithIAMNameServersList: S.Schema<DomainZoneWithIAMNameServersList>;
+/** DNS zone */
+export interface DomainZoneWithIAM {
+    /** Is DNSSEC activated for this zone */
+    dnssecActivated?: boolean;
+    /** Is DNSSEC supported by this zone */
+    dnssecSupported?: boolean;
+    /** Whether the DNS zone has a DNS Anycast subscription */
+    hasDnsAnycast?: boolean;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Last update date of the DNS zone */
+    lastUpdate?: string | null;
+    /** Zone name */
+    name?: string;
+    /** Name servers that host the DNS zone */
+    nameServers?: DomainZoneWithIAMNameServersList;
+}
+export declare const DomainZoneWithIAM: S.Schema<DomainZoneWithIAM>;
+export type GetZonesRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const GetZonesRequestIamTagsValueList: S.Schema<GetZonesRequestIamTagsValueList>;
+export type GetZonesRequestIamTagsMap = {
+    [key: string]: GetZonesRequestIamTagsValueList | undefined;
+};
+export declare const GetZonesRequestIamTagsMap: S.Schema<GetZonesRequestIamTagsMap>;
+export interface GetZonesRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: GetZonesRequestIamTagsMap;
+}
+export declare const GetZonesRequest: S.Schema<GetZonesRequest>;
+export type GetZonesResponseBodyList = Array<string>;
+export declare const GetZonesResponseBodyList: S.Schema<GetZonesResponseBodyList>;
+export type GetZonesResponse = GetZonesResponseBodyList;
+export declare const GetZonesResponse: S.Schema<GetZonesResponse>;
+export interface ImportDomainZoneRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Zone file that will be imported */
+    zoneFile: string;
+}
+export declare const ImportDomainZoneRequest: S.Schema<ImportDomainZoneRequest>;
+export interface ListDomainConfigurationObfuscatedEmailsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainConfigurationObfuscatedEmailsRequest: S.Schema<ListDomainConfigurationObfuscatedEmailsRequest>;
+/** The possible statuses of an email obfuscation */
+export type DomainConfigurationsObfuscationStatusEnum = "done" | "todo";
+export declare const DomainConfigurationsObfuscationStatusEnum: any;
+/** The possible types of contacts associated to a domain name */
+export type DomainConfigurationsContactTypeEnum = "admin" | "all" | "billing" | "owner" | "tech";
+export declare const DomainConfigurationsContactTypeEnum: any;
+/** Configuration of the email obfuscations for contacts related to a domain name */
+export interface DomainConfigurationsObfuscatedEmail {
+    /** Status of the email obfuscation */
+    status?: DomainConfigurationsObfuscationStatusEnum | null;
+    /** Type of the contact whose email is obfuscated by this configuration */
+    type?: DomainConfigurationsContactTypeEnum;
+    /** Obfuscated email address */
+    value?: string;
+}
+export declare const DomainConfigurationsObfuscatedEmail: S.Schema<DomainConfigurationsObfuscatedEmail>;
+export type ListDomainConfigurationObfuscatedEmailsResponseBodyList = Array<DomainConfigurationsObfuscatedEmail>;
+export declare const ListDomainConfigurationObfuscatedEmailsResponseBodyList: S.Schema<ListDomainConfigurationObfuscatedEmailsResponseBodyList>;
+export type ListDomainConfigurationObfuscatedEmailsResponse = ListDomainConfigurationObfuscatedEmailsResponseBodyList;
+export declare const ListDomainConfigurationObfuscatedEmailsResponse: S.Schema<ListDomainConfigurationObfuscatedEmailsResponse>;
+export interface ListDomainConfigurationOptinRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainConfigurationOptinRequest: S.Schema<ListDomainConfigurationOptinRequest>;
+/** Whois optin fields */
+export type DomainOptinFieldsEnum = "address" | "city" | "country" | "email" | "fax" | "name" | "organisation" | "phone" | "province" | "zip";
+export declare const DomainOptinFieldsEnum: any;
+/** Fields to display publicly on the Whois */
+export type DomainConfigurationsOptinFieldsList = Array<DomainOptinFieldsEnum | (string & {})>;
+export declare const DomainConfigurationsOptinFieldsList: S.Schema<DomainConfigurationsOptinFieldsList>;
+/** Configuration of the optin fields for contacts related to a domain name */
+export interface DomainConfigurationsOptin {
+    /** Fields to display publicly on the Whois */
+    fields?: DomainConfigurationsOptinFieldsList;
+    /** Type of the contact associated to the optin configuration */
+    type?: DomainConfigurationsContactTypeEnum | (string & {});
+}
+export declare const DomainConfigurationsOptin: S.Schema<DomainConfigurationsOptin>;
+export type ListDomainConfigurationOptinResponseBodyList = Array<DomainConfigurationsOptin>;
+export declare const ListDomainConfigurationOptinResponseBodyList: S.Schema<ListDomainConfigurationOptinResponseBodyList>;
+export type ListDomainConfigurationOptinResponse = ListDomainConfigurationOptinResponseBodyList;
+export declare const ListDomainConfigurationOptinResponse: S.Schema<ListDomainConfigurationOptinResponse>;
+export interface ListDomainDataSmdRequest {
+}
+export declare const ListDomainDataSmdRequest: S.Schema<ListDomainDataSmdRequest>;
+export type ListDomainDataSmdResponseBodyList = Array<DomainDataSmdSmd>;
+export declare const ListDomainDataSmdResponseBodyList: S.Schema<ListDomainDataSmdResponseBodyList>;
+export type ListDomainDataSmdResponse = ListDomainDataSmdResponseBodyList;
+export declare const ListDomainDataSmdResponse: S.Schema<ListDomainDataSmdResponse>;
+export interface ListDomainDsRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of flags property (=) */
+    flags?: DnssecKeyFlagEnum | (number & {});
+    /** Filter the value of status property (=) */
+    status?: DnssecKeyStatusEnum | (string & {});
+}
+export declare const ListDomainDsRecordRequest: S.Schema<ListDomainDsRecordRequest>;
+export type ListDomainDsRecordResponseBodyList = Array<number>;
+export declare const ListDomainDsRecordResponseBodyList: S.Schema<ListDomainDsRecordResponseBodyList>;
+export type ListDomainDsRecordResponse = ListDomainDsRecordResponseBodyList;
+export declare const ListDomainDsRecordResponse: S.Schema<ListDomainDsRecordResponse>;
+/** Type of extension category */
+export type DomainExtensionsCategoryTypeEnum = "geolocalization" | "thematic";
+export declare const DomainExtensionsCategoryTypeEnum: any;
+export type ListDomainExtensionByCategoryRequestCategoryTypeList = Array<DomainExtensionsCategoryTypeEnum | (string & {})>;
+export declare const ListDomainExtensionByCategoryRequestCategoryTypeList: S.Schema<ListDomainExtensionByCategoryRequestCategoryTypeList>;
+export interface ListDomainExtensionByCategoryRequest {
+    /** Filter by category types */
+    categoryType?: ListDomainExtensionByCategoryRequestCategoryTypeList;
+}
+export declare const ListDomainExtensionByCategoryRequest: S.Schema<ListDomainExtensionByCategoryRequest>;
+/** List of extensions */
+export type DomainExtensionsCategoryNameWithExtensionsExtensionsList = Array<string>;
+export declare const DomainExtensionsCategoryNameWithExtensionsExtensionsList: S.Schema<DomainExtensionsCategoryNameWithExtensionsExtensionsList>;
+/** Result of extensions by category request */
+export interface DomainExtensionsCategoryNameWithExtensions {
+    /** List of extensions */
+    extensions?: DomainExtensionsCategoryNameWithExtensionsExtensionsList;
+    /** Name of the category */
+    name?: string;
+}
+export declare const DomainExtensionsCategoryNameWithExtensions: S.Schema<DomainExtensionsCategoryNameWithExtensions>;
+/** Geolocalizations groups extensions by geographical place, like 'europe' */
+export type DomainExtensionsExtensionsByCategoryGeolocalizationList = Array<DomainExtensionsCategoryNameWithExtensions>;
+export declare const DomainExtensionsExtensionsByCategoryGeolocalizationList: S.Schema<DomainExtensionsExtensionsByCategoryGeolocalizationList>;
+/** Thematics groups extensions by a thematic like 'gastronomy' for '.pizza' */
+export type DomainExtensionsExtensionsByCategoryThematicList = Array<DomainExtensionsCategoryNameWithExtensions>;
+export declare const DomainExtensionsExtensionsByCategoryThematicList: S.Schema<DomainExtensionsExtensionsByCategoryThematicList>;
+/** Result of extensions by category request */
+export interface DomainExtensionsExtensionsByCategory {
+    /** Geolocalizations groups extensions by geographical place, like 'europe' */
+    geolocalization?: DomainExtensionsExtensionsByCategoryGeolocalizationList | null;
+    /** Thematics groups extensions by a thematic like 'gastronomy' for '.pizza' */
+    thematic?: DomainExtensionsExtensionsByCategoryThematicList | null;
+}
+export declare const DomainExtensionsExtensionsByCategory: S.Schema<DomainExtensionsExtensionsByCategory>;
+/** OVH subsidiaries */
+export type NichandleOvhSubsidiaryEnum = "CZ" | "DE" | "ES" | "EU" | "FI" | "FR" | "GB" | "IE" | "IT" | "LT" | "MA" | "NL" | "PL" | "PT" | "SN" | "TN";
+export declare const NichandleOvhSubsidiaryEnum: any;
+export interface ListDomainExtensionHighlightedRequest {
+    /** OVHcloud subsidiary targeted. Highlighted extensions are different from one subsidiary to another. Default to FR. */
+    ovhSubsidiary?: NichandleOvhSubsidiaryEnum | (string & {});
+}
+export declare const ListDomainExtensionHighlightedRequest: S.Schema<ListDomainExtensionHighlightedRequest>;
+export type ListDomainExtensionHighlightedResponseBodyList = Array<string>;
+export declare const ListDomainExtensionHighlightedResponseBodyList: S.Schema<ListDomainExtensionHighlightedResponseBodyList>;
+export type ListDomainExtensionHighlightedResponse = ListDomainExtensionHighlightedResponseBodyList;
+export declare const ListDomainExtensionHighlightedResponse: S.Schema<ListDomainExtensionHighlightedResponse>;
+export interface ListDomainExtensionPricingAttributesRequest {
+    /** OVHcloud subsidiary targeted. Attributes may be different from one subsidiary to another. Default to FR. */
+    ovhSubsidiary?: NichandleOvhSubsidiaryEnum | (string & {});
+}
+export declare const ListDomainExtensionPricingAttributesRequest: S.Schema<ListDomainExtensionPricingAttributesRequest>;
+/** Result of getting pricing attributes of an extension */
+export interface DomainExtensionsExtensionsPricingAttributes {
+    /** Parameter is true when the extension has been created recently and we want to highlight this fact */
+    brandNew?: boolean;
+    /** Extension name, like 'com' or 'co.uk' */
+    name?: string;
+    /** Parameter is true when the extension price has dropped recently and we want to highlight this fact */
+    priceDrop?: boolean;
+}
+export declare const DomainExtensionsExtensionsPricingAttributes: S.Schema<DomainExtensionsExtensionsPricingAttributes>;
+export type ListDomainExtensionPricingAttributesResponseBodyList = Array<DomainExtensionsExtensionsPricingAttributes>;
+export declare const ListDomainExtensionPricingAttributesResponseBodyList: S.Schema<ListDomainExtensionPricingAttributesResponseBodyList>;
+export type ListDomainExtensionPricingAttributesResponse = ListDomainExtensionPricingAttributesResponseBodyList;
+export declare const ListDomainExtensionPricingAttributesResponse: S.Schema<ListDomainExtensionPricingAttributesResponse>;
+/** Type used to change the order of extensions results */
+export type DomainExtensionsOrderByTypeEnum = "alphabetical" | "trending";
+export declare const DomainExtensionsOrderByTypeEnum: any;
+export interface ListDomainExtensionsRequest {
+    /** Filter only extensions related to this list of geolocalization places (comma separated). Default to empty. */
+    geolocalizations?: string;
+    /** Order results by name (alphabetical) or trending importance (trending). Default to alphabetical. */
+    orderBy?: DomainExtensionsOrderByTypeEnum | (string & {});
+    /** OVHcloud subsidiary targeted. Useful only when orderBy is equal to trending. Default to FR. */
+    ovhSubsidiary?: NichandleOvhSubsidiaryEnum | (string & {});
+    /** Filter only extensions related to this list of thematics (comma separated). Default to empty. */
+    thematics?: string;
+}
+export declare const ListDomainExtensionsRequest: S.Schema<ListDomainExtensionsRequest>;
+export type ListDomainExtensionsResponseBodyList = Array<string>;
+export declare const ListDomainExtensionsResponseBodyList: S.Schema<ListDomainExtensionsResponseBodyList>;
+export type ListDomainExtensionsResponse = ListDomainExtensionsResponseBodyList;
+export declare const ListDomainExtensionsResponse: S.Schema<ListDomainExtensionsResponse>;
+export interface ListDomainGlueRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of host property */
+    host?: string;
+}
+export declare const ListDomainGlueRecordRequest: S.Schema<ListDomainGlueRecordRequest>;
+export type ListDomainGlueRecordResponseBodyList = Array<string>;
+export declare const ListDomainGlueRecordResponseBodyList: S.Schema<ListDomainGlueRecordResponseBodyList>;
+export type ListDomainGlueRecordResponse = ListDomainGlueRecordResponseBodyList;
+export declare const ListDomainGlueRecordResponse: S.Schema<ListDomainGlueRecordResponse>;
+export interface ListDomainNameServerRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainNameServerRequest: S.Schema<ListDomainNameServerRequest>;
+export type ListDomainNameServerResponseBodyList = Array<number>;
+export declare const ListDomainNameServerResponseBodyList: S.Schema<ListDomainNameServerResponseBodyList>;
+export type ListDomainNameServerResponse = ListDomainNameServerResponseBodyList;
+export declare const ListDomainNameServerResponse: S.Schema<ListDomainNameServerResponse>;
+export interface ListDomainOptionRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainOptionRequest: S.Schema<ListDomainOptionRequest>;
+export type ListDomainOptionResponseBodyList = Array<DomainDomainOptionEnum>;
+export declare const ListDomainOptionResponseBodyList: S.Schema<ListDomainOptionResponseBodyList>;
+export type ListDomainOptionResponse = ListDomainOptionResponseBodyList;
+export declare const ListDomainOptionResponse: S.Schema<ListDomainOptionResponse>;
+export interface ListDomainRuleEmailsObfuscationRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainRuleEmailsObfuscationRequest: S.Schema<ListDomainRuleEmailsObfuscationRequest>;
+export type ListDomainRuleEmailsObfuscationResponseBodyList = Array<DomainConfigurationsContactTypeEnum>;
+export declare const ListDomainRuleEmailsObfuscationResponseBodyList: S.Schema<ListDomainRuleEmailsObfuscationResponseBodyList>;
+export type ListDomainRuleEmailsObfuscationResponse = ListDomainRuleEmailsObfuscationResponseBodyList;
+export declare const ListDomainRuleEmailsObfuscationResponse: S.Schema<ListDomainRuleEmailsObfuscationResponse>;
+export interface ListDomainRuleOptinRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainRuleOptinRequest: S.Schema<ListDomainRuleOptinRequest>;
+/** Fields to display publicly on the Whois */
+export type DomainRulesOptinFieldsList = Array<DomainOptinFieldsEnum>;
+export declare const DomainRulesOptinFieldsList: S.Schema<DomainRulesOptinFieldsList>;
+/** Representation of the optin rule */
+export interface DomainRulesOptin {
+    /** Fields to display publicly on the Whois */
+    fields?: DomainRulesOptinFieldsList;
+    /** Type of the contact associated to the optin rule */
+    type?: DomainConfigurationsContactTypeEnum;
+}
+export declare const DomainRulesOptin: S.Schema<DomainRulesOptin>;
+export type ListDomainRuleOptinResponseBodyList = Array<DomainRulesOptin>;
+export declare const ListDomainRuleOptinResponseBodyList: S.Schema<ListDomainRuleOptinResponseBodyList>;
+export type ListDomainRuleOptinResponse = ListDomainRuleOptinResponseBodyList;
+export declare const ListDomainRuleOptinResponse: S.Schema<ListDomainRuleOptinResponse>;
+export interface ListDomainTaskRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of function property (like) */
+    function?: string;
+    /** Filter the value of status property (=) */
+    status?: DomainOperationStatusEnum | (string & {});
+    /** Filter the value of type property (=) */
+    type?: DomainOperationTypeEnum | (string & {});
+}
+export declare const ListDomainTaskRequest: S.Schema<ListDomainTaskRequest>;
+export type ListDomainTaskResponseBodyList = Array<number>;
+export declare const ListDomainTaskResponseBodyList: S.Schema<ListDomainTaskResponseBodyList>;
+export type ListDomainTaskResponse = ListDomainTaskResponseBodyList;
+export declare const ListDomainTaskResponse: S.Schema<ListDomainTaskResponse>;
+export interface ListDomainUkRegistrarsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDomainUkRegistrarsRequest: S.Schema<ListDomainUkRegistrarsRequest>;
+/** Representation of a UK Registrar (used for outgoing transfer) */
+export interface DomainUkRegistrar {
+    /** Registrar name */
+    name?: string;
+    /** Registrar tag */
+    tag: string;
+}
+export declare const DomainUkRegistrar: S.Schema<DomainUkRegistrar>;
+export type ListDomainUkRegistrarsResponseBodyList = Array<DomainUkRegistrar>;
+export declare const ListDomainUkRegistrarsResponseBodyList: S.Schema<ListDomainUkRegistrarsResponseBodyList>;
+export type ListDomainUkRegistrarsResponse = ListDomainUkRegistrarsResponseBodyList;
+export declare const ListDomainUkRegistrarsResponse: S.Schema<ListDomainUkRegistrarsResponse>;
+export interface ListDomainZoneHistoryRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Filter using the value of creationDate property (>=) */
+    creationDate_from?: string;
+    /** Filter using the value of creationDate property (<=) */
+    creationDate_to?: string;
+}
+export declare const ListDomainZoneHistoryRequest: S.Schema<ListDomainZoneHistoryRequest>;
+export type ListDomainZoneHistoryResponseBodyList = Array<string>;
+export declare const ListDomainZoneHistoryResponseBodyList: S.Schema<ListDomainZoneHistoryResponseBodyList>;
+export type ListDomainZoneHistoryResponse = ListDomainZoneHistoryResponseBodyList;
+export declare const ListDomainZoneHistoryResponse: S.Schema<ListDomainZoneHistoryResponse>;
+export interface ListDomainZoneOptionRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const ListDomainZoneOptionRequest: S.Schema<ListDomainZoneOptionRequest>;
+export type ListDomainZoneOptionResponseBodyList = Array<string>;
+export declare const ListDomainZoneOptionResponseBodyList: S.Schema<ListDomainZoneOptionResponseBodyList>;
+export type ListDomainZoneOptionResponse = ListDomainZoneOptionResponseBodyList;
+export declare const ListDomainZoneOptionResponse: S.Schema<ListDomainZoneOptionResponse>;
+export interface ListDomainZoneStatusRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const ListDomainZoneStatusRequest: S.Schema<ListDomainZoneStatusRequest>;
+/** Error list if any */
+export type DomainZoneStatusErrorsList = Array<string>;
+export declare const DomainZoneStatusErrorsList: S.Schema<DomainZoneStatusErrorsList>;
+/** Warning list if any */
+export type DomainZoneStatusWarningsList = Array<string>;
+export declare const DomainZoneStatusWarningsList: S.Schema<DomainZoneStatusWarningsList>;
+/** DNS zone status */
+export interface DomainZoneStatus {
+    /** Error list if any */
+    errors?: DomainZoneStatusErrorsList | null;
+    /** Whether the zone is deployed or not */
+    isDeployed?: boolean;
+    /** Warning list if any */
+    warnings?: DomainZoneStatusWarningsList | null;
+}
+export declare const DomainZoneStatus: S.Schema<DomainZoneStatus>;
+export interface ListDomainZoneTaskRequest {
+    /** Zone name */
+    zoneName: string;
+    function?: DomainTaskFunctionEnum | (string & {});
+    status?: DomainTaskStatusEnum | (string & {});
+}
+export declare const ListDomainZoneTaskRequest: S.Schema<ListDomainZoneTaskRequest>;
+export type ListDomainZoneTaskResponseBodyList = Array<number>;
+export declare const ListDomainZoneTaskResponseBodyList: S.Schema<ListDomainZoneTaskResponseBodyList>;
+export type ListDomainZoneTaskResponse = ListDomainZoneTaskResponseBodyList;
+export declare const ListDomainZoneTaskResponse: S.Schema<ListDomainZoneTaskResponse>;
+/** Purposes of the domain */
+export type DomainConfigurationsCustomFieldsInputIsForList = Array<DomainIsForEnum | (string & {})>;
+export declare const DomainConfigurationsCustomFieldsInputIsForList: S.Schema<DomainConfigurationsCustomFieldsInputIsForList>;
+/** Representation of the domain custom fields */
+export interface DomainConfigurationsCustomFieldsInput {
+    /** Domain name audience */
+    audience?: string | null;
+    /** Purposes of the domain */
+    isFor?: DomainConfigurationsCustomFieldsInputIsForList | null;
+    /** Domain name other purpose */
+    otherPurpose?: string | null;
+    /** Reason of the purchase of this domain */
+    reason?: string | null;
+    /** Represented company */
+    represent?: string | null;
+}
+export declare const DomainConfigurationsCustomFieldsInput: S.Schema<DomainConfigurationsCustomFieldsInput>;
+export interface PutDomainConfigurationDataRequest {
+    /** Service name */
+    serviceName: string;
+    /** New domain custom fields */
+    customFields?: DomainConfigurationsCustomFieldsInput;
+}
+export declare const PutDomainConfigurationDataRequest: S.Schema<PutDomainConfigurationDataRequest>;
+/** Type of the contacts to request email obfuscation for */
+export type PutDomainConfigurationObfuscatedEmailsRequestContactsList = Array<DomainConfigurationsContactTypeEnum | (string & {})>;
+export declare const PutDomainConfigurationObfuscatedEmailsRequestContactsList: S.Schema<PutDomainConfigurationObfuscatedEmailsRequestContactsList>;
+export interface PutDomainConfigurationObfuscatedEmailsRequest {
+    /** Service name */
+    serviceName: string;
+    /** Type of the contacts to request email obfuscation for */
+    contacts: PutDomainConfigurationObfuscatedEmailsRequestContactsList;
+}
+export declare const PutDomainConfigurationObfuscatedEmailsRequest: S.Schema<PutDomainConfigurationObfuscatedEmailsRequest>;
+export type PutDomainConfigurationObfuscatedEmailsResponseBodyList = Array<DomainConfigurationsObfuscatedEmail>;
+export declare const PutDomainConfigurationObfuscatedEmailsResponseBodyList: S.Schema<PutDomainConfigurationObfuscatedEmailsResponseBodyList>;
+export type PutDomainConfigurationObfuscatedEmailsResponse = PutDomainConfigurationObfuscatedEmailsResponseBodyList;
+export declare const PutDomainConfigurationObfuscatedEmailsResponse: S.Schema<PutDomainConfigurationObfuscatedEmailsResponse>;
+/** New optin configuration */
+export type PutDomainConfigurationOptinRequestOptinList = Array<DomainConfigurationsOptin>;
+export declare const PutDomainConfigurationOptinRequestOptinList: S.Schema<PutDomainConfigurationOptinRequestOptinList>;
+export interface PutDomainConfigurationOptinRequest {
+    /** Service name */
+    serviceName: string;
+    /** New optin configuration */
+    optin?: PutDomainConfigurationOptinRequestOptinList;
+}
+export declare const PutDomainConfigurationOptinRequest: S.Schema<PutDomainConfigurationOptinRequest>;
+export type PutDomainConfigurationOptinResponseBodyList = Array<DomainConfigurationsOptin>;
+export declare const PutDomainConfigurationOptinResponseBodyList: S.Schema<PutDomainConfigurationOptinResponseBodyList>;
+export type PutDomainConfigurationOptinResponse = PutDomainConfigurationOptinResponseBodyList;
+export declare const PutDomainConfigurationOptinResponse: S.Schema<PutDomainConfigurationOptinResponse>;
+export interface PutDomainDataSmdRequest {
+    /** Smd ID */
+    smdId: string;
+    /** SMD file content in base64 */
+    data: string;
+}
+export declare const PutDomainDataSmdRequest: S.Schema<PutDomainDataSmdRequest>;
+export interface PutDomainServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutDomainServiceInfosRequest: S.Schema<PutDomainServiceInfosRequest>;
+export interface PutDomainServiceInfosResponse {
+}
+export declare const PutDomainServiceInfosResponse: S.Schema<PutDomainServiceInfosResponse>;
+export interface PutDomainZoneOptionServiceInfosRequest {
+    /** The internal name of your zone */
+    zoneName: string;
+    /** The option name */
+    name: string;
+    /** Renew type */
+    renew: ServiceRenewType;
+}
+export declare const PutDomainZoneOptionServiceInfosRequest: S.Schema<PutDomainZoneOptionServiceInfosRequest>;
+export interface PutDomainZoneOptionServiceInfosResponse {
+}
+export declare const PutDomainZoneOptionServiceInfosResponse: S.Schema<PutDomainZoneOptionServiceInfosResponse>;
+export interface PutDomainZoneServiceInfosRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutDomainZoneServiceInfosRequest: S.Schema<PutDomainZoneServiceInfosRequest>;
+export interface PutDomainZoneServiceInfosResponse {
+}
+export declare const PutDomainZoneServiceInfosResponse: S.Schema<PutDomainZoneServiceInfosResponse>;
+export interface PutDomainZoneSoaRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Email address of the DNS Administrator */
+    email?: string;
+    /** When a zone transfer fails, a countdown clock begins. When the number of seconds set in the expire field elapses, the nameserver stops answering for that zone file */
+    expire?: number;
+    /** Non-Existent Domain TTL, if the name server returns a negative response, the remote server should wait the number of seconds set in the nxDomainTtl field before trying again */
+    nxDomainTtl?: number;
+    /** The refresh value determines the interval in seconds between successful zone transfers of the entire zone file from a nameserver to another. */
+    refresh?: number;
+    /** The serial number is used to indicate which copy of the zone file is the most current. When editing zone files, you must increment the serial number */
+    serial?: number;
+    /** Primary authoritative server */
+    server?: string;
+    /** Time To Live in seconds */
+    ttl?: number;
+}
+export declare const PutDomainZoneSoaRequest: S.Schema<PutDomainZoneSoaRequest>;
+export interface PutDomainZoneSoaResponse {
+}
+export declare const PutDomainZoneSoaResponse: S.Schema<PutDomainZoneSoaResponse>;
+/** Type of the contacts to refresh email obfuscation for */
+export type RefreshDomainConfigurationsObfuscatedEmailRequestContactsList = Array<DomainConfigurationsContactTypeEnum | (string & {})>;
+export declare const RefreshDomainConfigurationsObfuscatedEmailRequestContactsList: S.Schema<RefreshDomainConfigurationsObfuscatedEmailRequestContactsList>;
+export interface RefreshDomainConfigurationsObfuscatedEmailRequest {
+    /** Service name */
+    serviceName: string;
+    /** Type of the contacts to refresh email obfuscation for */
+    contacts: RefreshDomainConfigurationsObfuscatedEmailRequestContactsList;
+}
+export declare const RefreshDomainConfigurationsObfuscatedEmailRequest: S.Schema<RefreshDomainConfigurationsObfuscatedEmailRequest>;
+export interface RefreshDomainConfigurationsObfuscatedEmailResponse {
+}
+export declare const RefreshDomainConfigurationsObfuscatedEmailResponse: S.Schema<RefreshDomainConfigurationsObfuscatedEmailResponse>;
+export interface RefreshZoneRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const RefreshZoneRequest: S.Schema<RefreshZoneRequest>;
+export interface RefreshZoneResponse {
+}
+export declare const RefreshZoneResponse: S.Schema<RefreshZoneResponse>;
+/** Resource record name */
+export type DomainZoneResettableNamedResolutionFieldTypeEnum = "A" | "MX";
+export declare const DomainZoneResettableNamedResolutionFieldTypeEnum: any;
+/** Record associated to domain zone reset */
+export interface DomainZoneResetRecord {
+    /** Field type associated to domain zone reset */
+    fieldType?: DomainZoneResettableNamedResolutionFieldTypeEnum | (string & {});
+    /** Target associated to domain zone reset */
+    target?: string;
+}
+export declare const DomainZoneResetRecord: S.Schema<DomainZoneResetRecord>;
+/** Records that will be set after reset */
+export type ResetDomainZoneRequestDnsRecordsList = Array<DomainZoneResetRecord>;
+export declare const ResetDomainZoneRequestDnsRecordsList: S.Schema<ResetDomainZoneRequestDnsRecordsList>;
+export interface ResetDomainZoneRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Records that will be set after reset */
+    DnsRecords?: ResetDomainZoneRequestDnsRecordsList;
+    /** Create only mandatory records */
+    minimized?: boolean;
+}
+export declare const ResetDomainZoneRequest: S.Schema<ResetDomainZoneRequest>;
+export interface ResetDomainZoneResponse {
+}
+export declare const ResetDomainZoneResponse: S.Schema<ResetDomainZoneResponse>;
+export interface RestoreDomainZoneHistoryRequest {
+    /** Zone name */
+    zoneName: string;
+    /** Creation date */
+    creationDate: string;
+}
+export declare const RestoreDomainZoneHistoryRequest: S.Schema<RestoreDomainZoneHistoryRequest>;
+export interface TerminateDomainZoneRequest {
+    /** Zone name */
+    zoneName: string;
+}
+export declare const TerminateDomainZoneRequest: S.Schema<TerminateDomainZoneRequest>;
+export type TerminateDomainZoneResponse = string;
+export declare const TerminateDomainZoneResponse: S.Schema<TerminateDomainZoneResponse>;
+export interface UpdateContactRequest {
+    /** Contact ID */
+    contactId: number;
+    /** Country of lawyer accreditation */
+    accreditationCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Lawyer accreditation number */
+    accreditationId?: string | null;
+    /** Organism of lawyer accreditation */
+    accreditationOrganism?: string | null;
+    /** Year of lawyer accreditation */
+    accreditationYear?: number | null;
+    /** The address of the contact */
+    address?: DomainContactAddress | null;
+    /** City of birth */
+    birthCity?: string | null;
+    /** Birth Country */
+    birthCountry?: NichandleCountryEnum | (string & {}) | null;
+    /** Birth date */
+    birthDay?: string | null;
+    /** Birth Zipcode */
+    birthZip?: string | null;
+    /** Cellphone number */
+    cellPhone?: string | null;
+    /** Company National Identification Number */
+    companyNationalIdentificationNumber?: string | null;
+    /** Email address */
+    email?: string | null;
+    /** Enterprise identifier */
+    enterpriseId?: string | null;
+    /** Fax number */
+    fax?: string | null;
+    /** First name */
+    firstName?: string | null;
+    /** Gender */
+    gender?: NichandleGenderEnum | (string & {}) | null;
+    /** INSEE identifier */
+    insee?: string | null;
+    /** Language */
+    language?: NichandleLanguageEnum | (string & {}) | null;
+    /** Last name */
+    lastName?: string | null;
+    legalForm?: NichandleLegalFormEnum | (string & {}) | null;
+    /** category of legalForm */
+    legalFormCategory?: string | null;
+    /** National Identification Number */
+    nationalIdentificationNumber?: string | null;
+    /** Nationality */
+    nationality?: NichandleCountryEnum | (string & {}) | null;
+    /** To whom is the organisation accountable */
+    organisationAccountable?: string | null;
+    /** What is the source of funding */
+    organisationFunding?: string | null;
+    /** Explain the source of funding if organisationFunding is other */
+    organisationFundingOther?: string | null;
+    /** Name of organisation */
+    organisationName?: string | null;
+    /** Role of your organisation */
+    organisationRole?: string | null;
+    /** Explain the role of your organisation if organisationRole is other */
+    organisationRoleOther?: string | null;
+    /** Status of the staff */
+    organisationStaffStatus?: string | null;
+    /** Explain the status of the staff if organisationStaffStatus is other */
+    organisationStaffStatusOther?: string | null;
+    /** type of organisation */
+    organisationType?: string | null;
+    /** Explain the type of organisation if organisationType is other */
+    organisationTypeOther?: string | null;
+    /** Phone number */
+    phone?: string | null;
+    /** Type of registrant document */
+    registrantDocumentType?: string | null;
+    /** Explain the type of registrant document if registrantDocumentType is other */
+    registrantDocumentTypeOther?: string | null;
+    /** The role in the organisation */
+    roleInOrganisation?: string | null;
+    /** Trademark related to the contact */
+    trademarkId?: string | null;
+    /** VAT number */
+    vat?: string | null;
+    /** Website */
+    website?: string | null;
+}
+export declare const UpdateContactRequest: S.Schema<UpdateContactRequest>;
+/** IP address */
+export type UpdateDomainGlueRecordRequestIpsList = Array<string>;
+export declare const UpdateDomainGlueRecordRequestIpsList: S.Schema<UpdateDomainGlueRecordRequestIpsList>;
+export interface UpdateDomainGlueRecordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Host */
+    host: string;
+    /** IP address */
+    ips: UpdateDomainGlueRecordRequestIpsList;
+}
+export declare const UpdateDomainGlueRecordRequest: S.Schema<UpdateDomainGlueRecordRequest>;
+/** Name servers to update */
+export type UpdateDomainNameServerRequestNameServersList = Array<DomainNameServerNameServerInput>;
+export declare const UpdateDomainNameServerRequestNameServersList: S.Schema<UpdateDomainNameServerRequestNameServersList>;
+export interface UpdateDomainNameServerRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name servers to update */
+    nameServers: UpdateDomainNameServerRequestNameServersList;
+}
+export declare const UpdateDomainNameServerRequest: S.Schema<UpdateDomainNameServerRequest>;
+export type ApproveDomainOutgoingTransferError = OvhOpError;
+/** Approve Outgoing Transfer for a domain */
+export declare const approveDomainOutgoingTransfer: API.OperationMethod<ApproveDomainOutgoingTransferRequest, ApproveDomainOutgoingTransferResponse, ApproveDomainOutgoingTransferError, OvhOpContext>;
+export type CancelDomainTaskError = OvhOpError;
+/** Cancel the task */
+export declare const cancelDomainTask: API.OperationMethod<CancelDomainTaskRequest, CancelDomainTaskResponse, CancelDomainTaskError, OvhOpContext>;
+export type CancelDomainZoneTaskError = OvhOpError;
+/** Cancel a zone task */
+export declare const cancelDomainZoneTask: API.OperationMethod<CancelDomainZoneTaskRequest, CancelDomainZoneTaskResponse, CancelDomainZoneTaskError, OvhOpContext>;
+export type ChangePasswordDynDnsLoginError = OvhOpError;
+/** Change password of the DynHost login */
+export declare const changePasswordDynDnsLogin: API.OperationMethod<ChangePasswordDynDnsLoginRequest, ChangePasswordDynDnsLoginResponse, ChangePasswordDynDnsLoginError, OvhOpContext>;
+export type CheckDomainConfigurationRuleError = OvhOpError;
+/** Validate a rule data for a specified domain */
+export declare const checkDomainConfigurationRule: API.OperationMethod<CheckDomainConfigurationRuleRequest, CheckDomainConfigurationRuleResponse, CheckDomainConfigurationRuleError, OvhOpContext>;
+export type ConfirmDomainZoneTerminationError = OvhOpError;
+/** Confirm service termination */
+export declare const confirmDomainZoneTermination: API.OperationMethod<ConfirmDomainZoneTerminationRequest, ConfirmDomainZoneTerminationResponse, ConfirmDomainZoneTerminationError, OvhOpContext>;
+export type CreateContactError = OvhOpError;
+/** Create a contact */
+export declare const createContact: API.OperationMethod<CreateContactRequest, DomainContact, CreateContactError, OvhOpContext>;
+export type CreateDomainChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createDomainChangeContact: API.OperationMethod<CreateDomainChangeContactRequest, CreateDomainChangeContactResponse, CreateDomainChangeContactError, OvhOpContext>;
+export type CreateDomainDataSmdError = OvhOpError;
+/** Create a SMD file */
+export declare const createDomainDataSmd: API.OperationMethod<CreateDomainDataSmdRequest, DomainDataSmdSmd, CreateDomainDataSmdError, OvhOpContext>;
+export type CreateDomainDsRecordError = OvhOpError;
+/** Update DS records */
+export declare const createDomainDsRecord: API.OperationMethod<CreateDomainDsRecordRequest, DomainTask, CreateDomainDsRecordError, OvhOpContext>;
+export type CreateDomainGlueRecordError = OvhOpError;
+/** Create a glue record */
+export declare const createDomainGlueRecord: API.OperationMethod<CreateDomainGlueRecordRequest, DomainTask, CreateDomainGlueRecordError, OvhOpContext>;
+export type CreateDomainNameServerError = OvhOpError;
+/** Add new name server */
+export declare const createDomainNameServer: API.OperationMethod<CreateDomainNameServerRequest, DomainTask, CreateDomainNameServerError, OvhOpContext>;
+export type CreateDomainOrderError = OvhOpError;
+/** Order a new domain name */
+export declare const createDomainOrder: API.OperationMethod<CreateDomainOrderRequest, DomainOrderOrderResponse, CreateDomainOrderError, OvhOpContext>;
+export type CreateDomainTaskAccelerateError = OvhOpError;
+/** Accelerate the task */
+export declare const createDomainTaskAccelerate: API.OperationMethod<CreateDomainTaskAccelerateRequest, CreateDomainTaskAccelerateResponse, CreateDomainTaskAccelerateError, OvhOpContext>;
+export type CreateDomainTaskRelaunchError = OvhOpError;
+/** Relaunch the task */
+export declare const createDomainTaskRelaunch: API.OperationMethod<CreateDomainTaskRelaunchRequest, CreateDomainTaskRelaunchResponse, CreateDomainTaskRelaunchError, OvhOpContext>;
+export type CreateDomainUkOutgoingTransferError = OvhOpError;
+/** Schedule an outgoing transfer task for this domain (.uk only) */
+export declare const createDomainUkOutgoingTransfer: API.OperationMethod<CreateDomainUkOutgoingTransferRequest, DomainTask, CreateDomainUkOutgoingTransferError, OvhOpContext>;
+export type CreateDomainZoneChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createDomainZoneChangeContact: API.OperationMethod<CreateDomainZoneChangeContactRequest, CreateDomainZoneChangeContactResponse, CreateDomainZoneChangeContactError, OvhOpContext>;
+export type CreateDomainZoneTaskAccelerateError = OvhOpError;
+/** Accelerate a zone task */
+export declare const createDomainZoneTaskAccelerate: API.OperationMethod<CreateDomainZoneTaskAccelerateRequest, CreateDomainZoneTaskAccelerateResponse, CreateDomainZoneTaskAccelerateError, OvhOpContext>;
+export type CreateDomainZoneTaskRelaunchError = OvhOpError;
+/** Restart a zone task */
+export declare const createDomainZoneTaskRelaunch: API.OperationMethod<CreateDomainZoneTaskRelaunchRequest, CreateDomainZoneTaskRelaunchResponse, CreateDomainZoneTaskRelaunchError, OvhOpContext>;
+export type CreateDynDnsLoginError = OvhOpError;
+/** Create a new login */
+export declare const createDynDnsLogin: API.OperationMethod<CreateDynDnsLoginRequest, DomainZoneDynHostLogin, CreateDynDnsLoginError, OvhOpContext>;
+export type CreateDynDnsRecordError = OvhOpError;
+/** Create a new record */
+export declare const createDynDnsRecord: API.OperationMethod<CreateDynDnsRecordRequest, DomainZoneDynHostRecord, CreateDynDnsRecordError, OvhOpContext>;
+export type CreateRecordError = OvhOpError;
+/** Create a new record (Don't forget to refresh the zone) */
+export declare const createRecord: API.OperationMethod<CreateRecordRequest, DomainZoneRecord, CreateRecordError, OvhOpContext>;
+export type CreateRedirectionError = OvhOpError;
+/** Create a new redirection (Don't forget to refresh the zone) */
+export declare const createRedirection: API.OperationMethod<CreateRedirectionRequest, DomainZoneRedirection, CreateRedirectionError, OvhOpContext>;
+export type DeleteDomainDataSmdError = OvhOpError;
+/** Delete a SMD file */
+export declare const deleteDomainDataSmd: API.OperationMethod<DeleteDomainDataSmdRequest, DeleteDomainDataSmdResponse, DeleteDomainDataSmdError, OvhOpContext>;
+export type DeleteDomainGlueRecordError = OvhOpError;
+/** Delete the glue record */
+export declare const deleteDomainGlueRecord: API.OperationMethod<DeleteDomainGlueRecordRequest, DomainTask, DeleteDomainGlueRecordError, OvhOpContext>;
+export type DeleteDomainNameServerError = OvhOpError;
+/** Delete a name server */
+export declare const deleteDomainNameServer: API.OperationMethod<DeleteDomainNameServerRequest, DomainTask, DeleteDomainNameServerError, OvhOpContext>;
+export type DeleteDomainOptionError = OvhOpError;
+/** Remove a given option */
+export declare const deleteDomainOption: API.OperationMethod<DeleteDomainOptionRequest, DeleteDomainOptionResponse, DeleteDomainOptionError, OvhOpContext>;
+export type DeleteDynHostLoginError = OvhOpError;
+/** Delete login object */
+export declare const deleteDynHostLogin: API.OperationMethod<DeleteDynHostLoginRequest, DeleteDynHostLoginResponse, DeleteDynHostLoginError, OvhOpContext>;
+export type DeleteDynHostRecordError = OvhOpError;
+/** Delete record object */
+export declare const deleteDynHostRecord: API.OperationMethod<DeleteDynHostRecordRequest, DeleteDynHostRecordResponse, DeleteDynHostRecordError, OvhOpContext>;
+export type DeleteRecordError = OvhOpError;
+/** Delete record object (Don't forget to refresh the zone) */
+export declare const deleteRecord: API.OperationMethod<DeleteRecordRequest, DeleteRecordResponse, DeleteRecordError, OvhOpContext>;
+export type DeleteRedirectionError = OvhOpError;
+/** Delete redirection object (Don't forget to refresh the zone) */
+export declare const deleteRedirection: API.OperationMethod<DeleteRedirectionRequest, DeleteRedirectionResponse, DeleteRedirectionError, OvhOpContext>;
+export type DisableDNSSECError = OvhOpError;
+/** Disable DNSSEC */
+export declare const disableDNSSEC: API.OperationMethod<DisableDNSSECRequest, DisableDNSSECResponse, DisableDNSSECError, OvhOpContext>;
+export type EditDomainError = OvhOpError;
+/** Edit domain name properties */
+export declare const editDomain: API.OperationMethod<EditDomainRequest, DomainDomainService, EditDomainError, OvhOpContext>;
+export type EditDynDnsLoginError = OvhOpError;
+/** Alter login object properties */
+export declare const editDynDnsLogin: API.OperationMethod<EditDynDnsLoginRequest, EditDynDnsLoginResponse, EditDynDnsLoginError, OvhOpContext>;
+export type EditDynDnsRecordError = OvhOpError;
+/** Alter record object properties */
+export declare const editDynDnsRecord: API.OperationMethod<EditDynDnsRecordRequest, EditDynDnsRecordResponse, EditDynDnsRecordError, OvhOpContext>;
+export type EditRecordError = OvhOpError;
+/** Alter record object properties (Don't forget to refresh the zone) */
+export declare const editRecord: API.OperationMethod<EditRecordRequest, EditRecordResponse, EditRecordError, OvhOpContext>;
+export type EditRedirectionError = OvhOpError;
+/** Alter redirection object properties */
+export declare const editRedirection: API.OperationMethod<EditRedirectionRequest, EditRedirectionResponse, EditRedirectionError, OvhOpContext>;
+export type EnableDNSSECError = OvhOpError;
+/** Enable DNSSEC */
+export declare const enableDNSSEC: API.OperationMethod<EnableDNSSECRequest, EnableDNSSECResponse, EnableDNSSECError, OvhOpContext>;
+export type GetContactError = OvhOpError;
+/** Get details about a contact */
+export declare const getContact: API.OperationMethod<GetContactRequest, DomainContact, GetContactError, OvhOpContext>;
+export type GetContactsError = OvhOpError;
+/** List all contacts */
+export declare const getContacts: API.OperationMethod<GetContactsRequest, GetContactsResponse, GetContactsError, OvhOpContext>;
+export type GetDNSSECStatusError = OvhOpError;
+/** Get a zone DNSSEC status */
+export declare const getDNSSECStatus: API.OperationMethod<GetDNSSECStatusRequest, DomainZoneDnssec, GetDNSSECStatusError, OvhOpContext>;
+export type GetDomainError = OvhOpError;
+/** Get domain name information */
+export declare const getDomain: API.OperationMethod<GetDomainRequest, DomainDomainServiceWithIAM, GetDomainError, OvhOpContext>;
+export type GetDomainAuthInfoError = OvhOpError;
+/** Return authInfo code if the domain is unlocked */
+export declare const getDomainAuthInfo: API.OperationMethod<GetDomainAuthInfoRequest, GetDomainAuthInfoResponse, GetDomainAuthInfoError, OvhOpContext>;
+export type GetDomainConfigurationDataError = OvhOpError;
+/** Get extra data configurations for a domain */
+export declare const getDomainConfigurationData: API.OperationMethod<GetDomainConfigurationDataRequest, DomainConfigurationsCustomFields, GetDomainConfigurationDataError, OvhOpContext>;
+export type GetDomainConfigurationRuleError = OvhOpError;
+/** Get configuration rule applied for a domain in a given action */
+export declare const getDomainConfigurationRule: API.OperationMethod<GetDomainConfigurationRuleRequest, DomainConfigurationRulesRule, GetDomainConfigurationRuleError, OvhOpContext>;
+export type GetDomainDataClaimNoticeError = OvhOpError;
+/** Retrieve claim notices associated to a domain */
+export declare const getDomainDataClaimNotice: API.OperationMethod<GetDomainDataClaimNoticeRequest, DomainDataClaimNoticeClaimNotice, GetDomainDataClaimNoticeError, OvhOpContext>;
+export type GetDomainDataSmdError = OvhOpError;
+/** Get details about a SMD file */
+export declare const getDomainDataSmd: API.OperationMethod<GetDomainDataSmdRequest, DomainDataSmdSmd, GetDomainDataSmdError, OvhOpContext>;
+export type GetDomainDsRecordError = OvhOpError;
+/** Get details on this DS Record */
+export declare const getDomainDsRecord: API.OperationMethod<GetDomainDsRecordRequest, DnssecKey, GetDomainDsRecordError, OvhOpContext>;
+export type GetDomainExtensionError = OvhOpError;
+/** Get an extension */
+export declare const getDomainExtension: API.OperationMethod<GetDomainExtensionRequest, DomainExtensionsExtension, GetDomainExtensionError, OvhOpContext>;
+export type GetDomainExtensionRegistryConfigurationsError = OvhOpError;
+/** Retrieve registry configuration for an extension */
+export declare const getDomainExtensionRegistryConfigurations: API.OperationMethod<GetDomainExtensionRegistryConfigurationsRequest, DomainExtensionsRegistryConfigurationsRegistryConfigurations, GetDomainExtensionRegistryConfigurationsError, OvhOpContext>;
+export type GetDomainGlueRecordError = OvhOpError;
+/** Get this glue record */
+export declare const getDomainGlueRecord: API.OperationMethod<GetDomainGlueRecordRequest, DomainGlueRecordGlueRecord, GetDomainGlueRecordError, OvhOpContext>;
+export type GetDomainNameServerError = OvhOpError;
+/** Get this name server configuration */
+export declare const getDomainNameServer: API.OperationMethod<GetDomainNameServerRequest, DomainNameServerFullNameServer, GetDomainNameServerError, OvhOpContext>;
+export type GetDomainNameServerStatusError = OvhOpError;
+/** Get name server status */
+export declare const getDomainNameServerStatus: API.OperationMethod<GetDomainNameServerStatusRequest, DomainNameServerNameServerStatus, GetDomainNameServerStatusError, OvhOpContext>;
+export type GetDomainOptionError = OvhOpError;
+/** Get details on this domain option */
+export declare const getDomainOption: API.OperationMethod<GetDomainOptionRequest, DomainOption, GetDomainOptionError, OvhOpContext>;
+export type GetDomainOptionsError = OvhOpError;
+/** Retrieve data about the options associated to a domain */
+export declare const getDomainOptions: API.OperationMethod<GetDomainOptionsRequest, DomainServiceOptions, GetDomainOptionsError, OvhOpContext>;
+export type GetDomainsError = OvhOpError;
+/** Get the list of managed domain names */
+export declare const getDomains: API.OperationMethod<GetDomainsRequest, GetDomainsResponse, GetDomainsError, OvhOpContext>;
+export type GetDomainServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getDomainServiceInfos: API.OperationMethod<GetDomainServiceInfosRequest, ServicesService, GetDomainServiceInfosError, OvhOpContext>;
+export type GetDomainTaskError = OvhOpError;
+/** Get details about a domain task */
+export declare const getDomainTask: API.OperationMethod<GetDomainTaskRequest, DomainTask, GetDomainTaskError, OvhOpContext>;
+export type GetDomainZoneCapabilitiesError = OvhOpError;
+/** Get zone capabilities */
+export declare const getDomainZoneCapabilities: API.OperationMethod<GetDomainZoneCapabilitiesRequest, DomainZoneCapabilities, GetDomainZoneCapabilitiesError, OvhOpContext>;
+export type GetDomainZoneExportError = OvhOpError;
+/** Export DNS zone */
+export declare const getDomainZoneExport: API.OperationMethod<GetDomainZoneExportRequest, GetDomainZoneExportResponse, GetDomainZoneExportError, OvhOpContext>;
+export type GetDomainZoneHistoryError = OvhOpError;
+/** Get a zone history */
+export declare const getDomainZoneHistory: API.OperationMethod<GetDomainZoneHistoryRequest, DomainZoneZoneRestorePoint, GetDomainZoneHistoryError, OvhOpContext>;
+export type GetDomainZoneOptionError = OvhOpError;
+/** Get zone option */
+export declare const getDomainZoneOption: API.OperationMethod<GetDomainZoneOptionRequest, DomainZoneOption, GetDomainZoneOptionError, OvhOpContext>;
+export type GetDomainZoneOptionServiceInfosError = OvhOpError;
+/** Get this object properties */
+export declare const getDomainZoneOptionServiceInfos: API.OperationMethod<GetDomainZoneOptionServiceInfosRequest, ServicesService, GetDomainZoneOptionServiceInfosError, OvhOpContext>;
+export type GetDomainZoneServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getDomainZoneServiceInfos: API.OperationMethod<GetDomainZoneServiceInfosRequest, ServicesService, GetDomainZoneServiceInfosError, OvhOpContext>;
+export type GetDomainZoneSoaError = OvhOpError;
+/** Get zone SOA */
+export declare const getDomainZoneSoa: API.OperationMethod<GetDomainZoneSoaRequest, DomainZoneSoa, GetDomainZoneSoaError, OvhOpContext>;
+export type GetDomainZoneTaskError = OvhOpError;
+/** Get a zone task */
+export declare const getDomainZoneTask: API.OperationMethod<GetDomainZoneTaskRequest, DomainZoneTask, GetDomainZoneTaskError, OvhOpContext>;
+export type GetDynHostLoginError = OvhOpError;
+/** Get login object properties */
+export declare const getDynHostLogin: API.OperationMethod<GetDynHostLoginRequest, DomainZoneDynHostLogin, GetDynHostLoginError, OvhOpContext>;
+export type GetDynHostLoginsError = OvhOpError;
+/** List login */
+export declare const getDynHostLogins: API.OperationMethod<GetDynHostLoginsRequest, GetDynHostLoginsResponse, GetDynHostLoginsError, OvhOpContext>;
+export type GetDynHostRecordError = OvhOpError;
+/** Get record object properties */
+export declare const getDynHostRecord: API.OperationMethod<GetDynHostRecordRequest, DomainZoneDynHostRecord, GetDynHostRecordError, OvhOpContext>;
+export type GetDynHostRecordsError = OvhOpError;
+/** List record */
+export declare const getDynHostRecords: API.OperationMethod<GetDynHostRecordsRequest, GetDynHostRecordsResponse, GetDynHostRecordsError, OvhOpContext>;
+export type GetRecordError = OvhOpError;
+/** Get record object properties */
+export declare const getRecord: API.OperationMethod<GetRecordRequest, DomainZoneRecord, GetRecordError, OvhOpContext>;
+export type GetRecordsError = OvhOpError;
+/** List record */
+export declare const getRecords: API.OperationMethod<GetRecordsRequest, GetRecordsResponse, GetRecordsError, OvhOpContext>;
+export type GetRedirectionError = OvhOpError;
+/** Get redirection object properties */
+export declare const getRedirection: API.OperationMethod<GetRedirectionRequest, DomainZoneRedirection, GetRedirectionError, OvhOpContext>;
+export type GetRedirectionsError = OvhOpError;
+/** List redirections */
+export declare const getRedirections: API.OperationMethod<GetRedirectionsRequest, GetRedirectionsResponse, GetRedirectionsError, OvhOpContext>;
+export type GetZoneError = OvhOpError;
+/** Get a dnsZone service */
+export declare const getZone: API.OperationMethod<GetZoneRequest, DomainZoneWithIAM, GetZoneError, OvhOpContext>;
+export type GetZonesError = OvhOpError;
+/** List dnsZone services */
+export declare const getZones: API.OperationMethod<GetZonesRequest, GetZonesResponse, GetZonesError, OvhOpContext>;
+export type ImportDomainZoneError = OvhOpError;
+/** Import a DNS zone from a zone file */
+export declare const importDomainZone: API.OperationMethod<ImportDomainZoneRequest, DomainZoneTask, ImportDomainZoneError, OvhOpContext>;
+export type ListDomainConfigurationObfuscatedEmailsError = OvhOpError;
+/** Retrieve obfuscated emails configuration */
+export declare const listDomainConfigurationObfuscatedEmails: API.OperationMethod<ListDomainConfigurationObfuscatedEmailsRequest, ListDomainConfigurationObfuscatedEmailsResponse, ListDomainConfigurationObfuscatedEmailsError, OvhOpContext>;
+export type ListDomainConfigurationOptinError = OvhOpError;
+/** Retrieve optin configuration */
+export declare const listDomainConfigurationOptin: API.OperationMethod<ListDomainConfigurationOptinRequest, ListDomainConfigurationOptinResponse, ListDomainConfigurationOptinError, OvhOpContext>;
+export type ListDomainDataSmdError = OvhOpError;
+/** List all SMD files */
+export declare const listDomainDataSmd: API.OperationMethod<ListDomainDataSmdRequest, ListDomainDataSmdResponse, ListDomainDataSmdError, OvhOpContext>;
+export type ListDomainDsRecordError = OvhOpError;
+/** List of domain's DS Records */
+export declare const listDomainDsRecord: API.OperationMethod<ListDomainDsRecordRequest, ListDomainDsRecordResponse, ListDomainDsRecordError, OvhOpContext>;
+export type ListDomainExtensionByCategoryError = OvhOpError;
+/** List extensions, grouped by category types (like 'thematic', 'geolocalization') and category names (like 'europe') */
+export declare const listDomainExtensionByCategory: API.OperationMethod<ListDomainExtensionByCategoryRequest, DomainExtensionsExtensionsByCategory, ListDomainExtensionByCategoryError, OvhOpContext>;
+export type ListDomainExtensionHighlightedError = OvhOpError;
+/** List highlighted extensions, ordered by decreased importance */
+export declare const listDomainExtensionHighlighted: API.OperationMethod<ListDomainExtensionHighlightedRequest, ListDomainExtensionHighlightedResponse, ListDomainExtensionHighlightedError, OvhOpContext>;
+export type ListDomainExtensionPricingAttributesError = OvhOpError;
+/** List extensions with their pricing attributes List extensions with their pricing attributes. It especially documents whether an extension has been implemented recently or whether the price has dropped. */
+export declare const listDomainExtensionPricingAttributes: API.OperationMethod<ListDomainExtensionPricingAttributesRequest, ListDomainExtensionPricingAttributesResponse, ListDomainExtensionPricingAttributesError, OvhOpContext>;
+export type ListDomainExtensionsError = OvhOpError;
+/** List all extensions */
+export declare const listDomainExtensions: API.OperationMethod<ListDomainExtensionsRequest, ListDomainExtensionsResponse, ListDomainExtensionsError, OvhOpContext>;
+export type ListDomainGlueRecordError = OvhOpError;
+/** List of glue records */
+export declare const listDomainGlueRecord: API.OperationMethod<ListDomainGlueRecordRequest, ListDomainGlueRecordResponse, ListDomainGlueRecordError, OvhOpContext>;
+export type ListDomainNameServerError = OvhOpError;
+/** List of current name servers */
+export declare const listDomainNameServer: API.OperationMethod<ListDomainNameServerRequest, ListDomainNameServerResponse, ListDomainNameServerError, OvhOpContext>;
+export type ListDomainOptionError = OvhOpError;
+/** List domain options */
+export declare const listDomainOption: API.OperationMethod<ListDomainOptionRequest, ListDomainOptionResponse, ListDomainOptionError, OvhOpContext>;
+export type ListDomainRuleEmailsObfuscationError = OvhOpError;
+/** Retrieve emails obfuscation rule */
+export declare const listDomainRuleEmailsObfuscation: API.OperationMethod<ListDomainRuleEmailsObfuscationRequest, ListDomainRuleEmailsObfuscationResponse, ListDomainRuleEmailsObfuscationError, OvhOpContext>;
+export type ListDomainRuleOptinError = OvhOpError;
+/** Retrieve optin rule */
+export declare const listDomainRuleOptin: API.OperationMethod<ListDomainRuleOptinRequest, ListDomainRuleOptinResponse, ListDomainRuleOptinError, OvhOpContext>;
+export type ListDomainTaskError = OvhOpError;
+/** List all domain tasks */
+export declare const listDomainTask: API.OperationMethod<ListDomainTaskRequest, ListDomainTaskResponse, ListDomainTaskError, OvhOpContext>;
+export type ListDomainUkRegistrarsError = OvhOpError;
+/** Return the list of all .uk registrars */
+export declare const listDomainUkRegistrars: API.OperationMethod<ListDomainUkRegistrarsRequest, ListDomainUkRegistrarsResponse, ListDomainUkRegistrarsError, OvhOpContext>;
+export type ListDomainZoneHistoryError = OvhOpError;
+/** List zone histories */
+export declare const listDomainZoneHistory: API.OperationMethod<ListDomainZoneHistoryRequest, ListDomainZoneHistoryResponse, ListDomainZoneHistoryError, OvhOpContext>;
+export type ListDomainZoneOptionError = OvhOpError;
+/** List zone options */
+export declare const listDomainZoneOption: API.OperationMethod<ListDomainZoneOptionRequest, ListDomainZoneOptionResponse, ListDomainZoneOptionError, OvhOpContext>;
+export type ListDomainZoneStatusError = OvhOpError;
+/** Get zone status */
+export declare const listDomainZoneStatus: API.OperationMethod<ListDomainZoneStatusRequest, DomainZoneStatus, ListDomainZoneStatusError, OvhOpContext>;
+export type ListDomainZoneTaskError = OvhOpError;
+/** List zone tasks */
+export declare const listDomainZoneTask: API.OperationMethod<ListDomainZoneTaskRequest, ListDomainZoneTaskResponse, ListDomainZoneTaskError, OvhOpContext>;
+export type PutDomainConfigurationDataError = OvhOpError;
+/** Save extra data configurations for a domain */
+export declare const putDomainConfigurationData: API.OperationMethod<PutDomainConfigurationDataRequest, DomainConfigurationsCustomFields, PutDomainConfigurationDataError, OvhOpContext>;
+export type PutDomainConfigurationObfuscatedEmailsError = OvhOpError;
+/** Save a new obfuscated emails configuration */
+export declare const putDomainConfigurationObfuscatedEmails: API.OperationMethod<PutDomainConfigurationObfuscatedEmailsRequest, PutDomainConfigurationObfuscatedEmailsResponse, PutDomainConfigurationObfuscatedEmailsError, OvhOpContext>;
+export type PutDomainConfigurationOptinError = OvhOpError;
+/** Save a new optin configuration */
+export declare const putDomainConfigurationOptin: API.OperationMethod<PutDomainConfigurationOptinRequest, PutDomainConfigurationOptinResponse, PutDomainConfigurationOptinError, OvhOpContext>;
+export type PutDomainDataSmdError = OvhOpError;
+/** Update a SMD file */
+export declare const putDomainDataSmd: API.OperationMethod<PutDomainDataSmdRequest, DomainDataSmdSmd, PutDomainDataSmdError, OvhOpContext>;
+export type PutDomainServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putDomainServiceInfos: API.OperationMethod<PutDomainServiceInfosRequest, PutDomainServiceInfosResponse, PutDomainServiceInfosError, OvhOpContext>;
+export type PutDomainZoneOptionServiceInfosError = OvhOpError;
+/** Alter this object properties */
+export declare const putDomainZoneOptionServiceInfos: API.OperationMethod<PutDomainZoneOptionServiceInfosRequest, PutDomainZoneOptionServiceInfosResponse, PutDomainZoneOptionServiceInfosError, OvhOpContext>;
+export type PutDomainZoneServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putDomainZoneServiceInfos: API.OperationMethod<PutDomainZoneServiceInfosRequest, PutDomainZoneServiceInfosResponse, PutDomainZoneServiceInfosError, OvhOpContext>;
+export type PutDomainZoneSoaError = OvhOpError;
+/** Update zone SOA */
+export declare const putDomainZoneSoa: API.OperationMethod<PutDomainZoneSoaRequest, PutDomainZoneSoaResponse, PutDomainZoneSoaError, OvhOpContext>;
+export type RefreshDomainConfigurationsObfuscatedEmailError = OvhOpError;
+/** Refresh an obfuscated emails configuration with new values */
+export declare const refreshDomainConfigurationsObfuscatedEmail: API.OperationMethod<RefreshDomainConfigurationsObfuscatedEmailRequest, RefreshDomainConfigurationsObfuscatedEmailResponse, RefreshDomainConfigurationsObfuscatedEmailError, OvhOpContext>;
+export type RefreshZoneError = OvhOpError;
+/** Refresh a DNS zone */
+export declare const refreshZone: API.OperationMethod<RefreshZoneRequest, RefreshZoneResponse, RefreshZoneError, OvhOpContext>;
+export type ResetDomainZoneError = OvhOpError;
+/** Reset a DNS zone */
+export declare const resetDomainZone: API.OperationMethod<ResetDomainZoneRequest, ResetDomainZoneResponse, ResetDomainZoneError, OvhOpContext>;
+export type RestoreDomainZoneHistoryError = OvhOpError;
+/** Restore a backup point */
+export declare const restoreDomainZoneHistory: API.OperationMethod<RestoreDomainZoneHistoryRequest, DomainZoneTask, RestoreDomainZoneHistoryError, OvhOpContext>;
+export type TerminateDomainZoneError = OvhOpError;
+/** Ask for the termination of your service */
+export declare const terminateDomainZone: API.OperationMethod<TerminateDomainZoneRequest, TerminateDomainZoneResponse, TerminateDomainZoneError, OvhOpContext>;
+export type UpdateContactError = OvhOpError;
+/** Update a contact */
+export declare const updateContact: API.OperationMethod<UpdateContactRequest, DomainContact, UpdateContactError, OvhOpContext>;
+export type UpdateDomainGlueRecordError = OvhOpError;
+/** Update the glue record */
+export declare const updateDomainGlueRecord: API.OperationMethod<UpdateDomainGlueRecordRequest, DomainTask, UpdateDomainGlueRecordError, OvhOpContext>;
+export type UpdateDomainNameServerError = OvhOpError;
+/** Update DNS servers */
+export declare const updateDomainNameServer: API.OperationMethod<UpdateDomainNameServerRequest, DomainTask, UpdateDomainNameServerError, OvhOpContext>;
+//# sourceMappingURL=domain.d.ts.map