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

package/lib/services/emaildomain.d.ts

@@ -0,0 +1,1913 @@
+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 };
+/** 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 ConfirmEmailDomainTerminationRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Commentary about your termination request */
+    commentary?: string;
+    /** Reason of your termination request */
+    reason?: ServiceTerminationReasonEnum | (string & {});
+    /** The termination token sent by mail to the admin contact */
+    token: string;
+}
+export declare const ConfirmEmailDomainTerminationRequest: S.Schema<ConfirmEmailDomainTerminationRequest>;
+export type ConfirmEmailDomainTerminationResponse = string;
+export declare const ConfirmEmailDomainTerminationResponse: S.Schema<ConfirmEmailDomainTerminationResponse>;
+export interface CreateEmailDomainAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account name */
+    accountName: string;
+    /** Description Account */
+    description?: string;
+    /** Account password */
+    password: string | Redacted.Redacted<string>;
+    /** Account size in bytes (default : 5000000000) (possible values : /email/domain/{domain}/allowedAccountSize ) */
+    size?: number;
+}
+export declare const CreateEmailDomainAccountRequest: S.Schema<CreateEmailDomainAccountRequest>;
+/** Possible values for pop action task */
+export type DomainDomainPopActionEnum = "addAccount" | "changeAccount" | "changePassword" | "deleteAccount" | "internalMigration" | "migration" | "temporaryTask" | "unknown";
+export declare const DomainDomainPopActionEnum: any;
+/** Task Pop List */
+export interface EmailDomainTaskPop {
+    /** Action of task */
+    action?: DomainDomainPopActionEnum;
+    /** Creation date of task */
+    date?: string;
+    /** Domain name of task */
+    domain?: string;
+    /** Id of task */
+    id?: number;
+    /** Account name of task */
+    name?: string;
+}
+export declare const EmailDomainTaskPop: S.Schema<EmailDomainTaskPop>;
+export interface CreateEmailDomainAccountChangePasswordRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** New password */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const CreateEmailDomainAccountChangePasswordRequest: S.Schema<CreateEmailDomainAccountChangePasswordRequest>;
+export interface CreateEmailDomainAccountDelegationRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** OVH customer unique identifier */
+    accountId: string;
+}
+export declare const CreateEmailDomainAccountDelegationRequest: S.Schema<CreateEmailDomainAccountDelegationRequest>;
+export type CreateEmailDomainAccountDelegationResponse = string;
+export declare const CreateEmailDomainAccountDelegationResponse: S.Schema<CreateEmailDomainAccountDelegationResponse>;
+/** Possible values for filter action */
+export type DomainDomainFilterActionEnum = "accept" | "account" | "delete" | "redirect";
+export declare const DomainDomainFilterActionEnum: any;
+/** Possible values for filter operation */
+export type DomainDomainFilterOperandEnum = "checkspf" | "contains" | "noContains";
+export declare const DomainDomainFilterOperandEnum: any;
+export interface CreateEmailDomainAccountFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Action of filter */
+    action: DomainDomainFilterActionEnum | (string & {});
+    /** Action parameter of filter */
+    actionParam?: string;
+    /** If true filter is active */
+    active: boolean;
+    /** Header to be filtered */
+    header: string;
+    /** Filter name */
+    name: string;
+    /** Rule of filter */
+    operand: DomainDomainFilterOperandEnum | (string & {});
+    /** Priority of filter */
+    priority: number;
+    /** Rule parameter of filter */
+    value: string;
+}
+export declare const CreateEmailDomainAccountFilterRequest: S.Schema<CreateEmailDomainAccountFilterRequest>;
+/** Task filter List */
+export interface EmailDomainTaskFilter {
+    /** Account name of task */
+    account?: string;
+    /** Action of task */
+    action?: string;
+    /** Domain name of task */
+    domain?: string;
+    /** Id of task */
+    id?: number;
+    /** Creation date of task */
+    timestamp?: string;
+}
+export declare const EmailDomainTaskFilter: S.Schema<EmailDomainTaskFilter>;
+export interface CreateEmailDomainAccountFilterChangeActivityRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+    /** New activity */
+    activity: boolean;
+}
+export declare const CreateEmailDomainAccountFilterChangeActivityRequest: S.Schema<CreateEmailDomainAccountFilterChangeActivityRequest>;
+export interface CreateEmailDomainAccountFilterChangePriorityRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+    /** New priority */
+    priority: number;
+}
+export declare const CreateEmailDomainAccountFilterChangePriorityRequest: S.Schema<CreateEmailDomainAccountFilterChangePriorityRequest>;
+export interface CreateEmailDomainAccountFilterRuleRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+    /** Header to be filtered */
+    header: string;
+    /** Rule of filter */
+    operand: DomainDomainFilterOperandEnum | (string & {});
+    /** Rule parameter of filter */
+    value: string;
+}
+export declare const CreateEmailDomainAccountFilterRuleRequest: S.Schema<CreateEmailDomainAccountFilterRuleRequest>;
+export interface CreateEmailDomainAclRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Deleguates rights to */
+    accountId: string;
+}
+export declare const CreateEmailDomainAclRequest: S.Schema<CreateEmailDomainAclRequest>;
+/** Email ACL */
+export interface EmailDomainAcl {
+    /** OVH customer unique identifier */
+    accountId?: string;
+}
+export declare const EmailDomainAcl: S.Schema<EmailDomainAcl>;
+export interface CreateEmailDomainChangeContactRequest {
+    /** Name of your domain name */
+    domain: 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 CreateEmailDomainChangeContactRequest: S.Schema<CreateEmailDomainChangeContactRequest>;
+export type CreateEmailDomainChangeContactResponseBodyList = Array<number>;
+export declare const CreateEmailDomainChangeContactResponseBodyList: S.Schema<CreateEmailDomainChangeContactResponseBodyList>;
+export type CreateEmailDomainChangeContactResponse = CreateEmailDomainChangeContactResponseBodyList;
+export declare const CreateEmailDomainChangeContactResponse: S.Schema<CreateEmailDomainChangeContactResponse>;
+/** Possible values for MX filter */
+export type DomainDomainMXFilterEnum = "CUSTOM" | "FULL_FILTERING" | "NO_FILTERING" | "REDIRECT" | "SIMPLE_FILTERING";
+export declare const DomainDomainMXFilterEnum: any;
+export interface CreateEmailDomainChangeDnsMXFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Target server for custom MX */
+    customTarget?: string;
+    /** New MX filter */
+    mxFilter: DomainDomainMXFilterEnum | (string & {});
+    /** Sub domain */
+    subDomain?: string;
+}
+export declare const CreateEmailDomainChangeDnsMXFilterRequest: S.Schema<CreateEmailDomainChangeDnsMXFilterRequest>;
+export interface CreateEmailDomainChangeDnsMXFilterResponse {
+}
+export declare const CreateEmailDomainChangeDnsMXFilterResponse: S.Schema<CreateEmailDomainChangeDnsMXFilterResponse>;
+export interface CreateEmailDomainDelegatedAccountChangePasswordRequest {
+    /** Email */
+    email: string;
+    /** New password */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const CreateEmailDomainDelegatedAccountChangePasswordRequest: S.Schema<CreateEmailDomainDelegatedAccountChangePasswordRequest>;
+export interface CreateEmailDomainDelegatedAccountFilterRequest {
+    /** Email */
+    email: string;
+    /** Action of filter */
+    action: DomainDomainFilterActionEnum | (string & {});
+    /** Action parameter of filter */
+    actionParam?: string;
+    /** If true filter is active */
+    active: boolean;
+    /** Header to be filtered */
+    header: string;
+    /** Filter name */
+    name: string;
+    /** Rule of filter */
+    operand: DomainDomainFilterOperandEnum | (string & {});
+    /** Priority of filter */
+    priority: number;
+    /** Rule parameter of filter */
+    value: string;
+}
+export declare const CreateEmailDomainDelegatedAccountFilterRequest: S.Schema<CreateEmailDomainDelegatedAccountFilterRequest>;
+export interface CreateEmailDomainDelegatedAccountFilterChangeActivityRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+    /** New activity */
+    activity: boolean;
+}
+export declare const CreateEmailDomainDelegatedAccountFilterChangeActivityRequest: S.Schema<CreateEmailDomainDelegatedAccountFilterChangeActivityRequest>;
+export interface CreateEmailDomainDelegatedAccountFilterChangePriorityRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+    /** New priority */
+    priority: number;
+}
+export declare const CreateEmailDomainDelegatedAccountFilterChangePriorityRequest: S.Schema<CreateEmailDomainDelegatedAccountFilterChangePriorityRequest>;
+export interface CreateEmailDomainDelegatedAccountFilterRuleRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+    /** Header to be filtered */
+    header: string;
+    /** Rule of filter */
+    operand: DomainDomainFilterOperandEnum | (string & {});
+    /** Rule parameter of filter */
+    value: string;
+}
+export declare const CreateEmailDomainDelegatedAccountFilterRuleRequest: S.Schema<CreateEmailDomainDelegatedAccountFilterRuleRequest>;
+export interface CreateEmailDomainDelegatedAccountResponderRequest {
+    /** Email */
+    email: string;
+    /** Content of responder */
+    content: string;
+    /** If true, emails will be copy to emailToCopy address */
+    copy: boolean;
+    /** Account where copy emails */
+    copyTo?: string;
+    /** Date of start responder */
+    from?: string;
+    /** Date of end responder */
+    to?: string;
+}
+export declare const CreateEmailDomainDelegatedAccountResponderRequest: S.Schema<CreateEmailDomainDelegatedAccountResponderRequest>;
+/** Possible values for pop action task */
+export type DomainDomainSpecialAccountActionEnum = "add" | "change" | "delete";
+export declare const DomainDomainSpecialAccountActionEnum: any;
+/** Possible type task */
+export type DomainDomainSpecialAccountTypeEnum = "25g" | "alias" | "delete" | "filter" | "forward" | "responder";
+export declare const DomainDomainSpecialAccountTypeEnum: any;
+/** Task special account List */
+export interface EmailDomainTaskSpecialAccount {
+    /** Account name of task */
+    account?: string;
+    /** Action of task */
+    action?: DomainDomainSpecialAccountActionEnum;
+    /** Creation date of task */
+    date?: string;
+    /** Domain name of task */
+    domain?: string;
+    /** Id of task */
+    id?: string;
+    /** Type of action filter */
+    type?: DomainDomainSpecialAccountTypeEnum;
+}
+export declare const EmailDomainTaskSpecialAccount: S.Schema<EmailDomainTaskSpecialAccount>;
+export interface CreateEmailDomainDelegatedAccountUsageRequest {
+    /** Email */
+    email: string;
+}
+export declare const CreateEmailDomainDelegatedAccountUsageRequest: S.Schema<CreateEmailDomainDelegatedAccountUsageRequest>;
+/** Structure of usage account */
+export interface DomainDomainUsageAccountStruct {
+    /** Timestamp */
+    date?: string | null;
+    /** Number of message in mailbox */
+    emailCount?: number | null;
+    /** Size of mailbox (bytes) */
+    quota?: number | null;
+}
+export declare const DomainDomainUsageAccountStruct: S.Schema<DomainDomainUsageAccountStruct>;
+/** Possible values for mailing list language */
+export type DomainDomainMlLanguageEnum = "de" | "en" | "es" | "fr" | "it" | "nl" | "pl" | "pt";
+export declare const DomainDomainMlLanguageEnum: any;
+/** Structure of imapCopy */
+export interface DomainDomainMlOptionsStruct {
+    /** If true, messages are moderate */
+    moderatorMessage?: boolean;
+    /** If true, enabled moderation for subscribe */
+    subscribeByModerator?: boolean;
+    /** If true, just user can post */
+    usersPostOnly?: boolean;
+}
+export declare const DomainDomainMlOptionsStruct: S.Schema<DomainDomainMlOptionsStruct>;
+export interface CreateEmailDomainMailingListRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Language of mailing list */
+    language: DomainDomainMlLanguageEnum | (string & {});
+    /** Mailing list name */
+    name: string;
+    /** Options of mailing list */
+    options: DomainDomainMlOptionsStruct;
+    /** Owner Email */
+    ownerEmail: string;
+    /** Email to reply of mailing list */
+    replyTo?: string;
+}
+export declare const CreateEmailDomainMailingListRequest: S.Schema<CreateEmailDomainMailingListRequest>;
+/** Task Mailing List */
+export interface EmailDomainTaskMl {
+    account?: string;
+    action?: string;
+    date?: string;
+    domain?: string;
+    id?: number;
+    language?: DomainDomainMlLanguageEnum;
+}
+export declare const EmailDomainTaskMl: S.Schema<EmailDomainTaskMl>;
+export interface CreateEmailDomainMailingListChangeOptionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Options of mailing list */
+    options: DomainDomainMlOptionsStruct;
+}
+export declare const CreateEmailDomainMailingListChangeOptionRequest: S.Schema<CreateEmailDomainMailingListChangeOptionRequest>;
+export interface CreateEmailDomainMailingListModeratorRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Email of moderator */
+    email: string;
+}
+export declare const CreateEmailDomainMailingListModeratorRequest: S.Schema<CreateEmailDomainMailingListModeratorRequest>;
+export interface CreateEmailDomainMailingListSubscriberRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Email of subscriber */
+    email: string;
+}
+export declare const CreateEmailDomainMailingListSubscriberRequest: S.Schema<CreateEmailDomainMailingListSubscriberRequest>;
+export interface CreateEmailDomainRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of redirection */
+    from: string;
+    /** If true keep a local copy */
+    localCopy: boolean;
+    /** Target of account */
+    to: string;
+}
+export declare const CreateEmailDomainRedirectionRequest: S.Schema<CreateEmailDomainRedirectionRequest>;
+export interface CreateEmailDomainRedirectionChangeRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id */
+    id: string;
+    /** Target of account */
+    to: string;
+}
+export declare const CreateEmailDomainRedirectionChangeRedirectionRequest: S.Schema<CreateEmailDomainRedirectionChangeRedirectionRequest>;
+export interface CreateEmailDomainResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account of domain */
+    account: string;
+    /** Content of responder */
+    content: string;
+    /** If false, emails will be dropped. If true and copyTo field is empty, emails will be delivered to your mailbox. If true and copyTo is set with an address, emails will be delivered to this address */
+    copy: boolean;
+    /** Account where copy emails */
+    copyTo?: string;
+    /** Date of start responder */
+    from?: string;
+    /** Date of end responder */
+    to?: string;
+}
+export declare const CreateEmailDomainResponderRequest: S.Schema<CreateEmailDomainResponderRequest>;
+export interface DeleteEmailDomainAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+}
+export declare const DeleteEmailDomainAccountRequest: S.Schema<DeleteEmailDomainAccountRequest>;
+export interface DeleteEmailDomainAccountDelegationRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** OVH customer unique identifier */
+    accountId: string;
+}
+export declare const DeleteEmailDomainAccountDelegationRequest: S.Schema<DeleteEmailDomainAccountDelegationRequest>;
+export type DeleteEmailDomainAccountDelegationResponse = string;
+export declare const DeleteEmailDomainAccountDelegationResponse: S.Schema<DeleteEmailDomainAccountDelegationResponse>;
+export interface DeleteEmailDomainAccountFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+}
+export declare const DeleteEmailDomainAccountFilterRequest: S.Schema<DeleteEmailDomainAccountFilterRequest>;
+export type DeleteEmailDomainAccountFilterResponseBodyList = Array<EmailDomainTaskFilter>;
+export declare const DeleteEmailDomainAccountFilterResponseBodyList: S.Schema<DeleteEmailDomainAccountFilterResponseBodyList>;
+export type DeleteEmailDomainAccountFilterResponse = DeleteEmailDomainAccountFilterResponseBodyList;
+export declare const DeleteEmailDomainAccountFilterResponse: S.Schema<DeleteEmailDomainAccountFilterResponse>;
+export interface DeleteEmailDomainAccountFilterRuleRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+    id: number;
+}
+export declare const DeleteEmailDomainAccountFilterRuleRequest: S.Schema<DeleteEmailDomainAccountFilterRuleRequest>;
+export type DeleteEmailDomainAccountFilterRuleResponseBodyList = Array<EmailDomainTaskFilter>;
+export declare const DeleteEmailDomainAccountFilterRuleResponseBodyList: S.Schema<DeleteEmailDomainAccountFilterRuleResponseBodyList>;
+export type DeleteEmailDomainAccountFilterRuleResponse = DeleteEmailDomainAccountFilterRuleResponseBodyList;
+export declare const DeleteEmailDomainAccountFilterRuleResponse: S.Schema<DeleteEmailDomainAccountFilterRuleResponse>;
+export interface DeleteEmailDomainAclRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** OVH customer unique identifier */
+    accountId: string;
+}
+export declare const DeleteEmailDomainAclRequest: S.Schema<DeleteEmailDomainAclRequest>;
+export interface DeleteEmailDomainAclResponse {
+}
+export declare const DeleteEmailDomainAclResponse: S.Schema<DeleteEmailDomainAclResponse>;
+export interface DeleteEmailDomainDelegatedAccountFilterRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+}
+export declare const DeleteEmailDomainDelegatedAccountFilterRequest: S.Schema<DeleteEmailDomainDelegatedAccountFilterRequest>;
+export type DeleteEmailDomainDelegatedAccountFilterResponseBodyList = Array<EmailDomainTaskFilter>;
+export declare const DeleteEmailDomainDelegatedAccountFilterResponseBodyList: S.Schema<DeleteEmailDomainDelegatedAccountFilterResponseBodyList>;
+export type DeleteEmailDomainDelegatedAccountFilterResponse = DeleteEmailDomainDelegatedAccountFilterResponseBodyList;
+export declare const DeleteEmailDomainDelegatedAccountFilterResponse: S.Schema<DeleteEmailDomainDelegatedAccountFilterResponse>;
+export interface DeleteEmailDomainDelegatedAccountFilterRuleRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+    id: number;
+}
+export declare const DeleteEmailDomainDelegatedAccountFilterRuleRequest: S.Schema<DeleteEmailDomainDelegatedAccountFilterRuleRequest>;
+export type DeleteEmailDomainDelegatedAccountFilterRuleResponseBodyList = Array<EmailDomainTaskFilter>;
+export declare const DeleteEmailDomainDelegatedAccountFilterRuleResponseBodyList: S.Schema<DeleteEmailDomainDelegatedAccountFilterRuleResponseBodyList>;
+export type DeleteEmailDomainDelegatedAccountFilterRuleResponse = DeleteEmailDomainDelegatedAccountFilterRuleResponseBodyList;
+export declare const DeleteEmailDomainDelegatedAccountFilterRuleResponse: S.Schema<DeleteEmailDomainDelegatedAccountFilterRuleResponse>;
+export interface DeleteEmailDomainDelegatedAccountResponderRequest {
+    /** Email */
+    email: string;
+}
+export declare const DeleteEmailDomainDelegatedAccountResponderRequest: S.Schema<DeleteEmailDomainDelegatedAccountResponderRequest>;
+export interface DeleteEmailDomainMailingListRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+}
+export declare const DeleteEmailDomainMailingListRequest: S.Schema<DeleteEmailDomainMailingListRequest>;
+export interface DeleteEmailDomainMailingListModeratorRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    email: string;
+}
+export declare const DeleteEmailDomainMailingListModeratorRequest: S.Schema<DeleteEmailDomainMailingListModeratorRequest>;
+export interface DeleteEmailDomainMailingListSubscriberRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    email: string;
+}
+export declare const DeleteEmailDomainMailingListSubscriberRequest: S.Schema<DeleteEmailDomainMailingListSubscriberRequest>;
+export interface DeleteEmailDomainRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id */
+    id: string;
+}
+export declare const DeleteEmailDomainRedirectionRequest: S.Schema<DeleteEmailDomainRedirectionRequest>;
+export interface DeleteEmailDomainResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    account: string;
+}
+export declare const DeleteEmailDomainResponderRequest: S.Schema<DeleteEmailDomainResponderRequest>;
+export interface GetEmailDomainRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const GetEmailDomainRequest: S.Schema<GetEmailDomainRequest>;
+/** List of allowed sizes for this domain in bytes */
+export type EmailDomainDomainServiceWithIAMAllowedAccountSizeList = Array<number>;
+export declare const EmailDomainDomainServiceWithIAMAllowedAccountSizeList: S.Schema<EmailDomainDomainServiceWithIAMAllowedAccountSizeList>;
+/** 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>;
+/** Result value for diagnose */
+export type EmailDomainDiagnoseEnum = "checkFail" | "invalid" | "none" | "unknown" | "valid";
+export declare const EmailDomainDiagnoseEnum: any;
+/** Possible values for status domain */
+export type DomainDomainStatusEnum = "close" | "ok" | "readOnly" | "unknown";
+export declare const DomainDomainStatusEnum: any;
+/** Domain service */
+export interface EmailDomainDomainServiceWithIAM {
+    /** List of allowed sizes for this domain in bytes */
+    allowedAccountSize?: EmailDomainDomainServiceWithIAMAllowedAccountSizeList | null;
+    /** Creation date of domain */
+    creationDate?: string | null;
+    /** Name of domain */
+    domain?: string;
+    /** Filerz of domain */
+    filerz?: number | null;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Result of MX check if current MX fit to OVH recommendations */
+    isMXValid?: EmailDomainDiagnoseEnum;
+    /** Result of SPF check if current SPF fit to OVH recommendations */
+    isSPFValid?: EmailDomainDiagnoseEnum;
+    /** Name of servicelinked with this domain */
+    linkTo?: string | null;
+    /** Name of new MXPlan service */
+    migratedMXPlanServiceName?: string | null;
+    /** Offer of email service */
+    offer?: string | null;
+    /** Domain Status */
+    status?: DomainDomainStatusEnum;
+}
+export declare const EmailDomainDomainServiceWithIAM: S.Schema<EmailDomainDomainServiceWithIAM>;
+export interface GetEmailDomainAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+}
+export declare const GetEmailDomainAccountRequest: S.Schema<GetEmailDomainAccountRequest>;
+/** Account List */
+export interface EmailDomainAccount {
+    /** Name of account */
+    accountName?: string;
+    /** Account description */
+    description?: string;
+    /** Name of domain */
+    domain?: string;
+    /** Email */
+    email?: string;
+    /** If true your account is blocked */
+    isBlocked?: boolean;
+    /** Size of your account in bytes */
+    size?: number;
+}
+export declare const EmailDomainAccount: S.Schema<EmailDomainAccount>;
+export interface GetEmailDomainAccountDelegationRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** OVH customer unique identifier */
+    accountId: string;
+}
+export declare const GetEmailDomainAccountDelegationRequest: S.Schema<GetEmailDomainAccountDelegationRequest>;
+/** Delegation List */
+export interface EmailDomainDelegation {
+    /** OVH customer unique identifier */
+    accountId?: string;
+}
+export declare const EmailDomainDelegation: S.Schema<EmailDomainDelegation>;
+export interface GetEmailDomainAccountFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+}
+export declare const GetEmailDomainAccountFilterRequest: S.Schema<GetEmailDomainAccountFilterRequest>;
+/** Filter List */
+export interface EmailDomainFilter {
+    /** Action of filter */
+    action?: DomainDomainFilterActionEnum | null;
+    /** Action parameter of filter */
+    actionParam?: string | null;
+    /** If true filter is active */
+    active?: boolean;
+    /** Domain name of filter */
+    domain?: string;
+    /** Filter name */
+    name?: string;
+    /** Account name of filter */
+    pop?: string;
+    /** Priority of filter */
+    priority?: number;
+}
+export declare const EmailDomainFilter: S.Schema<EmailDomainFilter>;
+export interface GetEmailDomainAccountFilterRuleRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+    id: number;
+}
+export declare const GetEmailDomainAccountFilterRuleRequest: S.Schema<GetEmailDomainAccountFilterRuleRequest>;
+/** Rule List */
+export interface EmailDomainRule {
+    /** Header to be filtered */
+    header?: string;
+    id?: number;
+    /** Rule of filter */
+    operand?: DomainDomainFilterOperandEnum;
+    /** Rule parameter of filter */
+    value?: string;
+}
+export declare const EmailDomainRule: S.Schema<EmailDomainRule>;
+export interface GetEmailDomainAccountMigrateRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Service name allowed as migration destination */
+    destinationServiceName: string;
+}
+export declare const GetEmailDomainAccountMigrateRequest: S.Schema<GetEmailDomainAccountMigrateRequest>;
+/** Types of migration service */
+export type EmailDomainMigrationServiceType = "EMAIL PRO" | "HOSTED EXCHANGE" | "PRIVATE EXCHANGE" | "PROVIDER EXCHANGE";
+export declare const EmailDomainMigrationServiceType: any;
+/** Migration service */
+export interface EmailDomainMigrationService {
+    /** Admin contact of service */
+    contactAdmin?: string;
+    /** Billing contact of service */
+    contactBilling?: string;
+    /** Tech contact of service */
+    contactTech?: string;
+    /** Creation date of service */
+    creation?: string;
+    /** Service name allowed as migration destination */
+    destinationServiceName?: string;
+    /** Expiration date of service */
+    expiration?: string;
+    /** Offer type of service */
+    type?: EmailDomainMigrationServiceType;
+}
+export declare const EmailDomainMigrationService: S.Schema<EmailDomainMigrationService>;
+export interface GetEmailDomainAccountMigrateDestinationEmailAddressRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Service name allowed as migration destination */
+    destinationServiceName: string;
+    /** Destination account name */
+    destinationEmailAddress: string;
+}
+export declare const GetEmailDomainAccountMigrateDestinationEmailAddressRequest: S.Schema<GetEmailDomainAccountMigrateDestinationEmailAddressRequest>;
+/** Migration account */
+export interface EmailDomainMigrationAccount {
+    /** Destination account name */
+    destinationEmailAddress?: string;
+    /** Account maximum size */
+    quota?: number;
+}
+export declare const EmailDomainMigrationAccount: S.Schema<EmailDomainMigrationAccount>;
+export interface GetEmailDomainAccountUsageRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+}
+export declare const GetEmailDomainAccountUsageRequest: S.Schema<GetEmailDomainAccountUsageRequest>;
+export interface GetEmailDomainAclRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** OVH customer unique identifier */
+    accountId: string;
+}
+export declare const GetEmailDomainAclRequest: S.Schema<GetEmailDomainAclRequest>;
+export interface GetEmailDomainDelegatedAccountRequest {
+    /** Email */
+    email: string;
+}
+export declare const GetEmailDomainDelegatedAccountRequest: S.Schema<GetEmailDomainDelegatedAccountRequest>;
+/** List of allowed sizes for this account in bytes */
+export type EmailDomainAccountDelegatedAllowedAccountSizeList = Array<number>;
+export declare const EmailDomainAccountDelegatedAllowedAccountSizeList: S.Schema<EmailDomainAccountDelegatedAllowedAccountSizeList>;
+/** Account List */
+export interface EmailDomainAccountDelegated {
+    /** Name of account */
+    accountName?: string;
+    /** List of allowed sizes for this account in bytes */
+    allowedAccountSize?: EmailDomainAccountDelegatedAllowedAccountSizeList | null;
+    /** Account description */
+    description?: string;
+    /** Name of domain */
+    domain?: string;
+    /** Email */
+    email?: string;
+    /** If true your account is blocked */
+    isBlocked?: boolean;
+    /** Size of your account in bytes */
+    size?: number;
+}
+export declare const EmailDomainAccountDelegated: S.Schema<EmailDomainAccountDelegated>;
+export interface GetEmailDomainDelegatedAccountFilterRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+}
+export declare const GetEmailDomainDelegatedAccountFilterRequest: S.Schema<GetEmailDomainDelegatedAccountFilterRequest>;
+export interface GetEmailDomainDelegatedAccountFilterRuleRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+    id: number;
+}
+export declare const GetEmailDomainDelegatedAccountFilterRuleRequest: S.Schema<GetEmailDomainDelegatedAccountFilterRuleRequest>;
+export interface GetEmailDomainDelegatedAccountResponderRequest {
+    /** Email */
+    email: string;
+}
+export declare const GetEmailDomainDelegatedAccountResponderRequest: S.Schema<GetEmailDomainDelegatedAccountResponderRequest>;
+/** Responder of account */
+export interface EmailDomainResponderAccount {
+    /** Name of account */
+    account?: string;
+    /** Content of responder */
+    content?: string;
+    /** If true, emails will be copy to emailToCopy address */
+    copy?: boolean;
+    /** Account where copy emails */
+    copyTo?: string | null;
+    /** Date of start responder */
+    from?: string | null;
+    /** Date of end responder */
+    to?: string | null;
+}
+export declare const EmailDomainResponderAccount: S.Schema<EmailDomainResponderAccount>;
+export interface GetEmailDomainDnsMXFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Sub domain */
+    subDomain?: string;
+}
+export declare const GetEmailDomainDnsMXFilterRequest: S.Schema<GetEmailDomainDnsMXFilterRequest>;
+export type GetEmailDomainDnsMXFilterResponse = DomainDomainMXFilterEnum;
+export declare const GetEmailDomainDnsMXFilterResponse: S.Schema<GetEmailDomainDnsMXFilterResponse>;
+export interface GetEmailDomainMailingListRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+}
+export declare const GetEmailDomainMailingListRequest: S.Schema<GetEmailDomainMailingListRequest>;
+/** Mailing List */
+export interface EmailDomainMailingList {
+    /** Id of mailing list */
+    id?: number;
+    /** Language of mailing list */
+    language?: DomainDomainMlLanguageEnum | null;
+    /** Name of mailing list */
+    name?: string;
+    /** Subscribers number of mailing list */
+    nbSubscribers?: number | null;
+    /** Last update subscribers */
+    nbSubscribersUpdateDate?: string | null;
+    /** Options of mailing list */
+    options?: DomainDomainMlOptionsStruct;
+    /** Owner email of mailing list */
+    ownerEmail?: string;
+    /** Email to reply of mailing list */
+    replyTo?: string;
+}
+export declare const EmailDomainMailingList: S.Schema<EmailDomainMailingList>;
+export interface GetEmailDomainMailingListLimitsRequest {
+    /** If true, messages are moderate */
+    moderatorMessage: boolean;
+}
+export declare const GetEmailDomainMailingListLimitsRequest: S.Schema<GetEmailDomainMailingListLimitsRequest>;
+/** Structure of mailinglist limits */
+export interface DomainDomainMlLimits {
+    /** Maximum number of subscribers */
+    subscribers?: number;
+}
+export declare const DomainDomainMlLimits: S.Schema<DomainDomainMlLimits>;
+export interface GetEmailDomainMailingListModeratorRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    email: string;
+}
+export declare const GetEmailDomainMailingListModeratorRequest: S.Schema<GetEmailDomainMailingListModeratorRequest>;
+/** Moderators List */
+export interface EmailDomainModerator {
+    domain?: string;
+    email?: string;
+    mailinglist?: string;
+}
+export declare const EmailDomainModerator: S.Schema<EmailDomainModerator>;
+export interface GetEmailDomainMailingListSubscriberRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    email: string;
+}
+export declare const GetEmailDomainMailingListSubscriberRequest: S.Schema<GetEmailDomainMailingListSubscriberRequest>;
+/** Subscribers List */
+export interface EmailDomainSubscriber {
+    domain?: string;
+    email?: string;
+    mailinglist?: string;
+}
+export declare const EmailDomainSubscriber: S.Schema<EmailDomainSubscriber>;
+export interface GetEmailDomainQuotaRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const GetEmailDomainQuotaRequest: S.Schema<GetEmailDomainQuotaRequest>;
+/** Values of quota account (pop, mailing list, redirection, responder and big pop) */
+export interface DomainDomainQuota {
+    /** Maximum number of mailboxes */
+    account?: number;
+    /** Maximum number of aliases */
+    alias?: number;
+    /** Maximum number of mailing lists */
+    mailingList?: number;
+    /** Maximum number of redirections */
+    redirection?: number;
+    /** Maximum number of responders */
+    responder?: number;
+}
+export declare const DomainDomainQuota: S.Schema<DomainDomainQuota>;
+export interface GetEmailDomainRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id */
+    id: string;
+}
+export declare const GetEmailDomainRedirectionRequest: S.Schema<GetEmailDomainRedirectionRequest>;
+/** Global Redirection */
+export interface EmailDomainRedirectionGlobal {
+    /** Name of redirection */
+    from?: string;
+    /** Id of redirection */
+    id?: string;
+    /** Target of redirection */
+    to?: string;
+}
+export declare const EmailDomainRedirectionGlobal: S.Schema<EmailDomainRedirectionGlobal>;
+export interface GetEmailDomainResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    account: string;
+}
+export declare const GetEmailDomainResponderRequest: S.Schema<GetEmailDomainResponderRequest>;
+/** Responder */
+export interface EmailDomainResponder {
+    /** Name of account */
+    account?: string;
+    /** Content of responder */
+    content?: string;
+    /** If false, emails will be dropped. If true and copyTo field is empty, emails will be delivered to your mailbox. If true and copyTo is set with an address, emails will be delivered to this address */
+    copy?: boolean;
+    /** Account where copy emails */
+    copyTo?: string | null;
+    /** Date of start responder */
+    from?: string | null;
+    /** Date of end responder */
+    to?: string | null;
+}
+export declare const EmailDomainResponder: S.Schema<EmailDomainResponder>;
+export interface GetEmailDomainServiceInfosRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const GetEmailDomainServiceInfosRequest: S.Schema<GetEmailDomainServiceInfosRequest>;
+/** 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" | "automaticV2024" | "manual" | "oneShot" | "option";
+export declare const ServiceRenewalTypeEnum: any;
+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 GetEmailDomainSummaryRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const GetEmailDomainSummaryRequest: S.Schema<GetEmailDomainSummaryRequest>;
+/** Values of number account (account, mailing list, redirection and responder) */
+export interface DomainDomainSummary {
+    /** Number of mailboxes */
+    account?: number;
+    /** Number of mailing lists */
+    mailingList?: number;
+    /** Number of redirections */
+    redirection?: number;
+    /** Number of responders */
+    responder?: number;
+}
+export declare const DomainDomainSummary: S.Schema<DomainDomainSummary>;
+export interface GetEmailDomainTaskAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id of task */
+    id: number;
+}
+export declare const GetEmailDomainTaskAccountRequest: S.Schema<GetEmailDomainTaskAccountRequest>;
+export interface GetEmailDomainTaskAllRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id of the task */
+    id: number;
+}
+export declare const GetEmailDomainTaskAllRequest: S.Schema<GetEmailDomainTaskAllRequest>;
+/** Possible values for domain task status */
+export type EmailDomainTaskStatusEnum = "cancelled" | "customerError" | "doing" | "done" | "init" | "ovhError" | "todo";
+export declare const EmailDomainTaskStatusEnum: any;
+/** Tasks */
+export interface EmailDomainTask {
+    /** Domain name of the task */
+    domain?: string;
+    /** Function of the task */
+    function?: string;
+    /** Id of the task */
+    id?: number;
+    /** Status of the task */
+    status?: EmailDomainTaskStatusEnum;
+}
+export declare const EmailDomainTask: S.Schema<EmailDomainTask>;
+export interface GetEmailDomainTaskFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id of task */
+    id: number;
+}
+export declare const GetEmailDomainTaskFilterRequest: S.Schema<GetEmailDomainTaskFilterRequest>;
+export interface GetEmailDomainTaskMailinglistRequest {
+    /** Name of your domain name */
+    domain: string;
+    id: number;
+}
+export declare const GetEmailDomainTaskMailinglistRequest: S.Schema<GetEmailDomainTaskMailinglistRequest>;
+export interface GetEmailDomainTaskRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id */
+    id: string;
+}
+export declare const GetEmailDomainTaskRedirectionRequest: S.Schema<GetEmailDomainTaskRedirectionRequest>;
+export interface GetEmailDomainTaskResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Id of task */
+    id: number;
+}
+export declare const GetEmailDomainTaskResponderRequest: S.Schema<GetEmailDomainTaskResponderRequest>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListEmailDomainRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListEmailDomainRequestIamTagsValueList: S.Schema<ListEmailDomainRequestIamTagsValueList>;
+export type ListEmailDomainRequestIamTagsMap = {
+    [key: string]: ListEmailDomainRequestIamTagsValueList | undefined;
+};
+export declare const ListEmailDomainRequestIamTagsMap: S.Schema<ListEmailDomainRequestIamTagsMap>;
+export interface ListEmailDomainRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListEmailDomainRequestIamTagsMap;
+}
+export declare const ListEmailDomainRequest: S.Schema<ListEmailDomainRequest>;
+export type ListEmailDomainResponseBodyList = Array<string>;
+export declare const ListEmailDomainResponseBodyList: S.Schema<ListEmailDomainResponseBodyList>;
+export type ListEmailDomainResponse = ListEmailDomainResponseBodyList;
+export declare const ListEmailDomainResponse: S.Schema<ListEmailDomainResponse>;
+export interface ListEmailDomainAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account name */
+    accountName?: string;
+    /** Account description */
+    description?: string;
+}
+export declare const ListEmailDomainAccountRequest: S.Schema<ListEmailDomainAccountRequest>;
+export type ListEmailDomainAccountResponseBodyList = Array<string>;
+export declare const ListEmailDomainAccountResponseBodyList: S.Schema<ListEmailDomainAccountResponseBodyList>;
+export type ListEmailDomainAccountResponse = ListEmailDomainAccountResponseBodyList;
+export declare const ListEmailDomainAccountResponse: S.Schema<ListEmailDomainAccountResponse>;
+export interface ListEmailDomainAccountDelegationRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+}
+export declare const ListEmailDomainAccountDelegationRequest: S.Schema<ListEmailDomainAccountDelegationRequest>;
+export type ListEmailDomainAccountDelegationResponseBodyList = Array<string>;
+export declare const ListEmailDomainAccountDelegationResponseBodyList: S.Schema<ListEmailDomainAccountDelegationResponseBodyList>;
+export type ListEmailDomainAccountDelegationResponse = ListEmailDomainAccountDelegationResponseBodyList;
+export declare const ListEmailDomainAccountDelegationResponse: S.Schema<ListEmailDomainAccountDelegationResponse>;
+export interface ListEmailDomainAccountFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+}
+export declare const ListEmailDomainAccountFilterRequest: S.Schema<ListEmailDomainAccountFilterRequest>;
+export type ListEmailDomainAccountFilterResponseBodyList = Array<string>;
+export declare const ListEmailDomainAccountFilterResponseBodyList: S.Schema<ListEmailDomainAccountFilterResponseBodyList>;
+export type ListEmailDomainAccountFilterResponse = ListEmailDomainAccountFilterResponseBodyList;
+export declare const ListEmailDomainAccountFilterResponse: S.Schema<ListEmailDomainAccountFilterResponse>;
+export interface ListEmailDomainAccountFilterRuleRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Filter name */
+    name: string;
+}
+export declare const ListEmailDomainAccountFilterRuleRequest: S.Schema<ListEmailDomainAccountFilterRuleRequest>;
+export type ListEmailDomainAccountFilterRuleResponseBodyList = Array<number>;
+export declare const ListEmailDomainAccountFilterRuleResponseBodyList: S.Schema<ListEmailDomainAccountFilterRuleResponseBodyList>;
+export type ListEmailDomainAccountFilterRuleResponse = ListEmailDomainAccountFilterRuleResponseBodyList;
+export declare const ListEmailDomainAccountFilterRuleResponse: S.Schema<ListEmailDomainAccountFilterRuleResponse>;
+export interface ListEmailDomainAccountMigrateRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Type of migration service */
+    type?: EmailDomainMigrationServiceType | (string & {});
+}
+export declare const ListEmailDomainAccountMigrateRequest: S.Schema<ListEmailDomainAccountMigrateRequest>;
+export type ListEmailDomainAccountMigrateResponseBodyList = Array<string>;
+export declare const ListEmailDomainAccountMigrateResponseBodyList: S.Schema<ListEmailDomainAccountMigrateResponseBodyList>;
+export type ListEmailDomainAccountMigrateResponse = ListEmailDomainAccountMigrateResponseBodyList;
+export declare const ListEmailDomainAccountMigrateResponse: S.Schema<ListEmailDomainAccountMigrateResponse>;
+export interface ListEmailDomainAccountMigrateDestinationEmailAddressRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Service name allowed as migration destination */
+    destinationServiceName: string;
+    /** Account maximum size */
+    quota?: number;
+}
+export declare const ListEmailDomainAccountMigrateDestinationEmailAddressRequest: S.Schema<ListEmailDomainAccountMigrateDestinationEmailAddressRequest>;
+export type ListEmailDomainAccountMigrateDestinationEmailAddressResponseBodyList = Array<string>;
+export declare const ListEmailDomainAccountMigrateDestinationEmailAddressResponseBodyList: S.Schema<ListEmailDomainAccountMigrateDestinationEmailAddressResponseBodyList>;
+export type ListEmailDomainAccountMigrateDestinationEmailAddressResponse = ListEmailDomainAccountMigrateDestinationEmailAddressResponseBodyList;
+export declare const ListEmailDomainAccountMigrateDestinationEmailAddressResponse: S.Schema<ListEmailDomainAccountMigrateDestinationEmailAddressResponse>;
+export interface ListEmailDomainAccountMigrateDestinationEmailAddressCheckMigrateRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Service name allowed as migration destination */
+    destinationServiceName: string;
+    /** Destination account name */
+    destinationEmailAddress: string;
+}
+export declare const ListEmailDomainAccountMigrateDestinationEmailAddressCheckMigrateRequest: S.Schema<ListEmailDomainAccountMigrateDestinationEmailAddressCheckMigrateRequest>;
+/** List of aliases */
+export type EmailDomainMigrationCheckStructAliasList = Array<string>;
+export declare const EmailDomainMigrationCheckStructAliasList: S.Schema<EmailDomainMigrationCheckStructAliasList>;
+/** Result code of check migration */
+export type EmailDomainMigrationCheckCodeEnum = "ACCOUNT_EMPTY" | "ACCOUNT_INPROGRESS" | "DELEGATION_EXIST" | "DOMAIN_EMPTY" | "FILTER_EXIST" | "FORWARD_EXIST" | "FORWARD_LOCAL" | "MAILINGLIST_EXIST" | "MAILINGLIST_INPROGRESS" | "MAILPROXY_BAD_INFRA" | "MAILPROXY_EMPTY" | "MAILPROXY_INPROGRESS" | "MAILPROXY_RESERVATION" | "REDIRECTION_INPROGRESS" | "RESPONDER_EXIST" | "RESPONDER_INPROGRESS" | "UNKNOW";
+export declare const EmailDomainMigrationCheckCodeEnum: any;
+/** Check Migration result */
+export interface EmailDomainMigrationCheckResultStruct {
+    /** Result code of check migration */
+    code?: EmailDomainMigrationCheckCodeEnum;
+    /** Details of result code */
+    details?: string | null;
+}
+export declare const EmailDomainMigrationCheckResultStruct: S.Schema<EmailDomainMigrationCheckResultStruct>;
+/** List of errors */
+export type EmailDomainMigrationCheckStructErrorList = Array<EmailDomainMigrationCheckResultStruct>;
+export declare const EmailDomainMigrationCheckStructErrorList: S.Schema<EmailDomainMigrationCheckStructErrorList>;
+/** List of filters */
+export type EmailDomainMigrationCheckStructFilterList = Array<string>;
+export declare const EmailDomainMigrationCheckStructFilterList: S.Schema<EmailDomainMigrationCheckStructFilterList>;
+/** List of forwards */
+export type EmailDomainMigrationCheckStructForwardList = Array<string>;
+export declare const EmailDomainMigrationCheckStructForwardList: S.Schema<EmailDomainMigrationCheckStructForwardList>;
+/** List of warnings */
+export type EmailDomainMigrationCheckStructWarningList = Array<EmailDomainMigrationCheckResultStruct>;
+export declare const EmailDomainMigrationCheckStructWarningList: S.Schema<EmailDomainMigrationCheckStructWarningList>;
+/** Check Migration result */
+export interface EmailDomainMigrationCheckStruct {
+    /** List of aliases */
+    alias?: EmailDomainMigrationCheckStructAliasList | null;
+    /** List of errors */
+    error?: EmailDomainMigrationCheckStructErrorList | null;
+    /** List of filters */
+    filter?: EmailDomainMigrationCheckStructFilterList | null;
+    /** List of forwards */
+    forward?: EmailDomainMigrationCheckStructForwardList | null;
+    /** List of warnings */
+    warning?: EmailDomainMigrationCheckStructWarningList | null;
+}
+export declare const EmailDomainMigrationCheckStruct: S.Schema<EmailDomainMigrationCheckStruct>;
+export interface ListEmailDomainAclRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const ListEmailDomainAclRequest: S.Schema<ListEmailDomainAclRequest>;
+export type ListEmailDomainAclResponseBodyList = Array<string>;
+export declare const ListEmailDomainAclResponseBodyList: S.Schema<ListEmailDomainAclResponseBodyList>;
+export type ListEmailDomainAclResponse = ListEmailDomainAclResponseBodyList;
+export declare const ListEmailDomainAclResponse: S.Schema<ListEmailDomainAclResponse>;
+export interface ListEmailDomainDelegatedAccountRequest {
+    /** Name of email address */
+    accountName?: string;
+    /** Domain of email address */
+    domain?: string;
+}
+export declare const ListEmailDomainDelegatedAccountRequest: S.Schema<ListEmailDomainDelegatedAccountRequest>;
+export type ListEmailDomainDelegatedAccountResponseBodyList = Array<string>;
+export declare const ListEmailDomainDelegatedAccountResponseBodyList: S.Schema<ListEmailDomainDelegatedAccountResponseBodyList>;
+export type ListEmailDomainDelegatedAccountResponse = ListEmailDomainDelegatedAccountResponseBodyList;
+export declare const ListEmailDomainDelegatedAccountResponse: S.Schema<ListEmailDomainDelegatedAccountResponse>;
+export interface ListEmailDomainDelegatedAccountFilterRequest {
+    /** Email */
+    email: string;
+}
+export declare const ListEmailDomainDelegatedAccountFilterRequest: S.Schema<ListEmailDomainDelegatedAccountFilterRequest>;
+export type ListEmailDomainDelegatedAccountFilterResponseBodyList = Array<string>;
+export declare const ListEmailDomainDelegatedAccountFilterResponseBodyList: S.Schema<ListEmailDomainDelegatedAccountFilterResponseBodyList>;
+export type ListEmailDomainDelegatedAccountFilterResponse = ListEmailDomainDelegatedAccountFilterResponseBodyList;
+export declare const ListEmailDomainDelegatedAccountFilterResponse: S.Schema<ListEmailDomainDelegatedAccountFilterResponse>;
+export interface ListEmailDomainDelegatedAccountFilterRuleRequest {
+    /** Email */
+    email: string;
+    /** Filter name */
+    name: string;
+}
+export declare const ListEmailDomainDelegatedAccountFilterRuleRequest: S.Schema<ListEmailDomainDelegatedAccountFilterRuleRequest>;
+export type ListEmailDomainDelegatedAccountFilterRuleResponseBodyList = Array<number>;
+export declare const ListEmailDomainDelegatedAccountFilterRuleResponseBodyList: S.Schema<ListEmailDomainDelegatedAccountFilterRuleResponseBodyList>;
+export type ListEmailDomainDelegatedAccountFilterRuleResponse = ListEmailDomainDelegatedAccountFilterRuleResponseBodyList;
+export declare const ListEmailDomainDelegatedAccountFilterRuleResponse: S.Schema<ListEmailDomainDelegatedAccountFilterRuleResponse>;
+export interface ListEmailDomainDkimRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const ListEmailDomainDkimRequest: S.Schema<ListEmailDomainDkimRequest>;
+/** Status of DKIM selector */
+export type EmailDomainDKIMSelectorStatusEnum = "set" | "toFix" | "toSet";
+export declare const EmailDomainDKIMSelectorStatusEnum: any;
+/** DKIM selector data for a domain */
+export interface EmailDomainDKIMSelector {
+    /** CNAME record */
+    cname?: string;
+    /** Internal name of selector */
+    selectorName?: string;
+    /** Status of selector */
+    status?: EmailDomainDKIMSelectorStatusEnum;
+}
+export declare const EmailDomainDKIMSelector: S.Schema<EmailDomainDKIMSelector>;
+/** DKIM status */
+export type EmailDomainDkimSimplifiedSelectorsList = Array<EmailDomainDKIMSelector>;
+export declare const EmailDomainDkimSimplifiedSelectorsList: S.Schema<EmailDomainDkimSimplifiedSelectorsList>;
+/** Status of DKIM deployment */
+export type EmailDomainDKIMStatusEnum = "disabled" | "enabled" | "error" | "modifying" | "toConfigure";
+export declare const EmailDomainDKIMStatusEnum: any;
+/** DKIM for a domain */
+export interface EmailDomainDkimSimplified {
+    /** activeSelector */
+    activeSelector?: string | null;
+    /** If true your DNS CNAME configuration is valid */
+    autoconfig?: boolean | null;
+    /** DKIM status */
+    selectors?: EmailDomainDkimSimplifiedSelectorsList | null;
+    /** DKIM status */
+    status?: EmailDomainDKIMStatusEnum;
+}
+export declare const EmailDomainDkimSimplified: S.Schema<EmailDomainDkimSimplified>;
+export interface ListEmailDomainDnsMXRecordsRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Sub domain */
+    subDomain?: string;
+}
+export declare const ListEmailDomainDnsMXRecordsRequest: S.Schema<ListEmailDomainDnsMXRecordsRequest>;
+export type ListEmailDomainDnsMXRecordsResponseBodyList = Array<string>;
+export declare const ListEmailDomainDnsMXRecordsResponseBodyList: S.Schema<ListEmailDomainDnsMXRecordsResponseBodyList>;
+export type ListEmailDomainDnsMXRecordsResponse = ListEmailDomainDnsMXRecordsResponseBodyList;
+export declare const ListEmailDomainDnsMXRecordsResponse: S.Schema<ListEmailDomainDnsMXRecordsResponse>;
+export interface ListEmailDomainMailingListRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Mailing list name */
+    name?: string;
+}
+export declare const ListEmailDomainMailingListRequest: S.Schema<ListEmailDomainMailingListRequest>;
+export type ListEmailDomainMailingListResponseBodyList = Array<string>;
+export declare const ListEmailDomainMailingListResponseBodyList: S.Schema<ListEmailDomainMailingListResponseBodyList>;
+export type ListEmailDomainMailingListResponse = ListEmailDomainMailingListResponseBodyList;
+export declare const ListEmailDomainMailingListResponse: S.Schema<ListEmailDomainMailingListResponse>;
+export interface ListEmailDomainMailingListModeratorRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Moderator email */
+    email?: string;
+}
+export declare const ListEmailDomainMailingListModeratorRequest: S.Schema<ListEmailDomainMailingListModeratorRequest>;
+export type ListEmailDomainMailingListModeratorResponseBodyList = Array<string>;
+export declare const ListEmailDomainMailingListModeratorResponseBodyList: S.Schema<ListEmailDomainMailingListModeratorResponseBodyList>;
+export type ListEmailDomainMailingListModeratorResponse = ListEmailDomainMailingListModeratorResponseBodyList;
+export declare const ListEmailDomainMailingListModeratorResponse: S.Schema<ListEmailDomainMailingListModeratorResponse>;
+export interface ListEmailDomainMailingListSubscriberRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Subscriber email */
+    email?: string;
+}
+export declare const ListEmailDomainMailingListSubscriberRequest: S.Schema<ListEmailDomainMailingListSubscriberRequest>;
+export type ListEmailDomainMailingListSubscriberResponseBodyList = Array<string>;
+export declare const ListEmailDomainMailingListSubscriberResponseBodyList: S.Schema<ListEmailDomainMailingListSubscriberResponseBodyList>;
+export type ListEmailDomainMailingListSubscriberResponse = ListEmailDomainMailingListSubscriberResponseBodyList;
+export declare const ListEmailDomainMailingListSubscriberResponse: S.Schema<ListEmailDomainMailingListSubscriberResponse>;
+export interface ListEmailDomainRecommendedDNSRecordsRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const ListEmailDomainRecommendedDNSRecordsRequest: S.Schema<ListEmailDomainRecommendedDNSRecordsRequest>;
+/** Types of DNS record for fieldType */
+export type EmailDomainDnsRecordTypeEnum = "A" | "AAAA" | "CAA" | "CNAME" | "DKIM" | "DMARC" | "DNAME" | "LOC" | "MX" | "NAPTR" | "NS" | "PTR" | "SPF" | "SRV" | "SSHFP" | "TLSA" | "TXT";
+export declare const EmailDomainDnsRecordTypeEnum: any;
+/** DNS record for email services */
+export interface EmailDomainRecord {
+    /** Type of DNS record */
+    fieldType?: EmailDomainDnsRecordTypeEnum;
+    /** Id of record */
+    id?: number;
+    /** subdomain of record */
+    subDomain?: string | null;
+    /** Target of DNS record */
+    target?: string;
+    /** TTL of record */
+    ttl?: number | null;
+    /** Name of DNS zone */
+    zone?: string;
+}
+export declare const EmailDomainRecord: S.Schema<EmailDomainRecord>;
+export type ListEmailDomainRecommendedDNSRecordsResponseBodyList = Array<EmailDomainRecord>;
+export declare const ListEmailDomainRecommendedDNSRecordsResponseBodyList: S.Schema<ListEmailDomainRecommendedDNSRecordsResponseBodyList>;
+export type ListEmailDomainRecommendedDNSRecordsResponse = ListEmailDomainRecommendedDNSRecordsResponseBodyList;
+export declare const ListEmailDomainRecommendedDNSRecordsResponse: S.Schema<ListEmailDomainRecommendedDNSRecordsResponse>;
+export interface ListEmailDomainRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of redirection */
+    from?: string;
+    /** Email of redirection target */
+    to?: string;
+}
+export declare const ListEmailDomainRedirectionRequest: S.Schema<ListEmailDomainRedirectionRequest>;
+export type ListEmailDomainRedirectionResponseBodyList = Array<string>;
+export declare const ListEmailDomainRedirectionResponseBodyList: S.Schema<ListEmailDomainRedirectionResponseBodyList>;
+export type ListEmailDomainRedirectionResponse = ListEmailDomainRedirectionResponseBodyList;
+export declare const ListEmailDomainRedirectionResponse: S.Schema<ListEmailDomainRedirectionResponse>;
+export interface ListEmailDomainResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Responder name */
+    account?: string;
+}
+export declare const ListEmailDomainResponderRequest: S.Schema<ListEmailDomainResponderRequest>;
+export type ListEmailDomainResponderResponseBodyList = Array<string>;
+export declare const ListEmailDomainResponderResponseBodyList: S.Schema<ListEmailDomainResponderResponseBodyList>;
+export type ListEmailDomainResponderResponse = ListEmailDomainResponderResponseBodyList;
+export declare const ListEmailDomainResponderResponse: S.Schema<ListEmailDomainResponderResponse>;
+export interface ListEmailDomainTaskAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account name */
+    name?: string;
+}
+export declare const ListEmailDomainTaskAccountRequest: S.Schema<ListEmailDomainTaskAccountRequest>;
+export type ListEmailDomainTaskAccountResponseBodyList = Array<number>;
+export declare const ListEmailDomainTaskAccountResponseBodyList: S.Schema<ListEmailDomainTaskAccountResponseBodyList>;
+export type ListEmailDomainTaskAccountResponse = ListEmailDomainTaskAccountResponseBodyList;
+export declare const ListEmailDomainTaskAccountResponse: S.Schema<ListEmailDomainTaskAccountResponse>;
+export interface ListEmailDomainTaskAllRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const ListEmailDomainTaskAllRequest: S.Schema<ListEmailDomainTaskAllRequest>;
+export type ListEmailDomainTaskAllResponseBodyList = Array<number>;
+export declare const ListEmailDomainTaskAllResponseBodyList: S.Schema<ListEmailDomainTaskAllResponseBodyList>;
+export type ListEmailDomainTaskAllResponse = ListEmailDomainTaskAllResponseBodyList;
+export declare const ListEmailDomainTaskAllResponse: S.Schema<ListEmailDomainTaskAllResponse>;
+export interface ListEmailDomainTaskFilterRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account name */
+    account?: string;
+}
+export declare const ListEmailDomainTaskFilterRequest: S.Schema<ListEmailDomainTaskFilterRequest>;
+export type ListEmailDomainTaskFilterResponseBodyList = Array<number>;
+export declare const ListEmailDomainTaskFilterResponseBodyList: S.Schema<ListEmailDomainTaskFilterResponseBodyList>;
+export type ListEmailDomainTaskFilterResponse = ListEmailDomainTaskFilterResponseBodyList;
+export declare const ListEmailDomainTaskFilterResponse: S.Schema<ListEmailDomainTaskFilterResponse>;
+export interface ListEmailDomainTaskMailinglistRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account name */
+    account?: string;
+}
+export declare const ListEmailDomainTaskMailinglistRequest: S.Schema<ListEmailDomainTaskMailinglistRequest>;
+export type ListEmailDomainTaskMailinglistResponseBodyList = Array<number>;
+export declare const ListEmailDomainTaskMailinglistResponseBodyList: S.Schema<ListEmailDomainTaskMailinglistResponseBodyList>;
+export type ListEmailDomainTaskMailinglistResponse = ListEmailDomainTaskMailinglistResponseBodyList;
+export declare const ListEmailDomainTaskMailinglistResponse: S.Schema<ListEmailDomainTaskMailinglistResponse>;
+export interface ListEmailDomainTaskRedirectionRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Account name */
+    account?: string;
+}
+export declare const ListEmailDomainTaskRedirectionRequest: S.Schema<ListEmailDomainTaskRedirectionRequest>;
+export type ListEmailDomainTaskRedirectionResponseBodyList = Array<string>;
+export declare const ListEmailDomainTaskRedirectionResponseBodyList: S.Schema<ListEmailDomainTaskRedirectionResponseBodyList>;
+export type ListEmailDomainTaskRedirectionResponse = ListEmailDomainTaskRedirectionResponseBodyList;
+export declare const ListEmailDomainTaskRedirectionResponse: S.Schema<ListEmailDomainTaskRedirectionResponse>;
+export interface ListEmailDomainTaskResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of responder */
+    account?: string;
+}
+export declare const ListEmailDomainTaskResponderRequest: S.Schema<ListEmailDomainTaskResponderRequest>;
+export type ListEmailDomainTaskResponderResponseBodyList = Array<number>;
+export declare const ListEmailDomainTaskResponderResponseBodyList: S.Schema<ListEmailDomainTaskResponderResponseBodyList>;
+export type ListEmailDomainTaskResponderResponse = ListEmailDomainTaskResponderResponseBodyList;
+export declare const ListEmailDomainTaskResponderResponse: S.Schema<ListEmailDomainTaskResponderResponse>;
+export interface MigrateEmailDomainAccountMigrateDestinationEmailAddressRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Service name allowed as migration destination */
+    destinationServiceName: string;
+    /** Destination account name */
+    destinationEmailAddress: string;
+    /** New password used for migration */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const MigrateEmailDomainAccountMigrateDestinationEmailAddressRequest: S.Schema<MigrateEmailDomainAccountMigrateDestinationEmailAddressRequest>;
+export interface MigrateEmailDomainDelegationV3toV6Request {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const MigrateEmailDomainDelegationV3toV6Request: S.Schema<MigrateEmailDomainDelegationV3toV6Request>;
+export interface MigrateEmailDomainDelegationV3toV6Response {
+}
+export declare const MigrateEmailDomainDelegationV3toV6Response: S.Schema<MigrateEmailDomainDelegationV3toV6Response>;
+export interface PutEmailDomainAccountRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+    /** Account description */
+    description?: string;
+    /** Size of your account in bytes */
+    size?: number;
+}
+export declare const PutEmailDomainAccountRequest: S.Schema<PutEmailDomainAccountRequest>;
+export interface PutEmailDomainAccountResponse {
+}
+export declare const PutEmailDomainAccountResponse: S.Schema<PutEmailDomainAccountResponse>;
+export interface PutEmailDomainDelegatedAccountRequest {
+    /** Email */
+    email: string;
+    /** Account description */
+    description?: string;
+    /** Size of your account in bytes */
+    size?: number;
+}
+export declare const PutEmailDomainDelegatedAccountRequest: S.Schema<PutEmailDomainDelegatedAccountRequest>;
+export interface PutEmailDomainDelegatedAccountResponse {
+}
+export declare const PutEmailDomainDelegatedAccountResponse: S.Schema<PutEmailDomainDelegatedAccountResponse>;
+export interface PutEmailDomainDelegatedAccountResponderRequest {
+    /** Email */
+    email: string;
+    /** Content of responder */
+    content?: string;
+    /** Date of start responder */
+    from?: string | null;
+    /** Date of end responder */
+    to?: string | null;
+}
+export declare const PutEmailDomainDelegatedAccountResponderRequest: S.Schema<PutEmailDomainDelegatedAccountResponderRequest>;
+export interface PutEmailDomainDelegatedAccountResponderResponse {
+}
+export declare const PutEmailDomainDelegatedAccountResponderResponse: S.Schema<PutEmailDomainDelegatedAccountResponderResponse>;
+export interface PutEmailDomainDkimDisableRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const PutEmailDomainDkimDisableRequest: S.Schema<PutEmailDomainDkimDisableRequest>;
+export interface PutEmailDomainDkimEnableRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const PutEmailDomainDkimEnableRequest: S.Schema<PutEmailDomainDkimEnableRequest>;
+export interface PutEmailDomainMailingListRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Language of mailing list */
+    language?: DomainDomainMlLanguageEnum | (string & {}) | null;
+    /** Owner email of mailing list */
+    ownerEmail?: string;
+    /** Email to reply of mailing list */
+    replyTo?: string;
+}
+export declare const PutEmailDomainMailingListRequest: S.Schema<PutEmailDomainMailingListRequest>;
+export interface PutEmailDomainMailingListResponse {
+}
+export declare const PutEmailDomainMailingListResponse: S.Schema<PutEmailDomainMailingListResponse>;
+export interface PutEmailDomainResponderRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    account: string;
+    /** Content of responder */
+    content?: string;
+    /** Date of start responder */
+    from?: string | null;
+    /** Date of end responder */
+    to?: string | null;
+}
+export declare const PutEmailDomainResponderRequest: S.Schema<PutEmailDomainResponderRequest>;
+export interface PutEmailDomainResponderResponse {
+}
+export declare const PutEmailDomainResponderResponse: S.Schema<PutEmailDomainResponderResponse>;
+export interface PutEmailDomainServiceInfosRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutEmailDomainServiceInfosRequest: S.Schema<PutEmailDomainServiceInfosRequest>;
+export interface PutEmailDomainServiceInfosResponse {
+}
+export declare const PutEmailDomainServiceInfosResponse: S.Schema<PutEmailDomainServiceInfosResponse>;
+export interface SendEmailDomainMailingListListByEmailRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of mailing list */
+    name: string;
+    /** Email destination */
+    email: string;
+}
+export declare const SendEmailDomainMailingListListByEmailRequest: S.Schema<SendEmailDomainMailingListListByEmailRequest>;
+export interface TerminateEmailDomainRequest {
+    /** Name of your domain name */
+    domain: string;
+}
+export declare const TerminateEmailDomainRequest: S.Schema<TerminateEmailDomainRequest>;
+export type TerminateEmailDomainResponse = string;
+export declare const TerminateEmailDomainResponse: S.Schema<TerminateEmailDomainResponse>;
+export interface UpdateEmailDomainAccountUsageRequest {
+    /** Name of your domain name */
+    domain: string;
+    /** Name of account */
+    accountName: string;
+}
+export declare const UpdateEmailDomainAccountUsageRequest: S.Schema<UpdateEmailDomainAccountUsageRequest>;
+export interface UpdateEmailDomainAccountUsageResponse {
+}
+export declare const UpdateEmailDomainAccountUsageResponse: S.Schema<UpdateEmailDomainAccountUsageResponse>;
+export interface UpdateEmailDomainDelegatedAccountUsageRequest {
+    /** Email */
+    email: string;
+}
+export declare const UpdateEmailDomainDelegatedAccountUsageRequest: S.Schema<UpdateEmailDomainDelegatedAccountUsageRequest>;
+export interface UpdateEmailDomainDelegatedAccountUsageResponse {
+}
+export declare const UpdateEmailDomainDelegatedAccountUsageResponse: S.Schema<UpdateEmailDomainDelegatedAccountUsageResponse>;
+export type ConfirmEmailDomainTerminationError = OvhOpError;
+/** Confirm termination of your email service */
+export declare const confirmEmailDomainTermination: API.OperationMethod<ConfirmEmailDomainTerminationRequest, ConfirmEmailDomainTerminationResponse, ConfirmEmailDomainTerminationError, OvhOpContext>;
+export type CreateEmailDomainAccountError = OvhOpError;
+/** Create new mailbox in server */
+export declare const createEmailDomainAccount: API.OperationMethod<CreateEmailDomainAccountRequest, EmailDomainTaskPop, CreateEmailDomainAccountError, OvhOpContext>;
+export type CreateEmailDomainAccountChangePasswordError = OvhOpError;
+/** Change mailbox password (length : [9;30], no space at begin and end, no accent) */
+export declare const createEmailDomainAccountChangePassword: API.OperationMethod<CreateEmailDomainAccountChangePasswordRequest, EmailDomainTaskPop, CreateEmailDomainAccountChangePasswordError, OvhOpContext>;
+export type CreateEmailDomainAccountDelegationError = OvhOpError;
+/** Create delegation for this account */
+export declare const createEmailDomainAccountDelegation: API.OperationMethod<CreateEmailDomainAccountDelegationRequest, CreateEmailDomainAccountDelegationResponse, CreateEmailDomainAccountDelegationError, OvhOpContext>;
+export type CreateEmailDomainAccountFilterError = OvhOpError;
+/** Create new filter for account */
+export declare const createEmailDomainAccountFilter: API.OperationMethod<CreateEmailDomainAccountFilterRequest, EmailDomainTaskFilter, CreateEmailDomainAccountFilterError, OvhOpContext>;
+export type CreateEmailDomainAccountFilterChangeActivityError = OvhOpError;
+/** Change filter activity */
+export declare const createEmailDomainAccountFilterChangeActivity: API.OperationMethod<CreateEmailDomainAccountFilterChangeActivityRequest, EmailDomainTaskFilter, CreateEmailDomainAccountFilterChangeActivityError, OvhOpContext>;
+export type CreateEmailDomainAccountFilterChangePriorityError = OvhOpError;
+/** Change filter priority */
+export declare const createEmailDomainAccountFilterChangePriority: API.OperationMethod<CreateEmailDomainAccountFilterChangePriorityRequest, EmailDomainTaskFilter, CreateEmailDomainAccountFilterChangePriorityError, OvhOpContext>;
+export type CreateEmailDomainAccountFilterRuleError = OvhOpError;
+/** Create new rule for filter */
+export declare const createEmailDomainAccountFilterRule: API.OperationMethod<CreateEmailDomainAccountFilterRuleRequest, EmailDomainTaskFilter, CreateEmailDomainAccountFilterRuleError, OvhOpContext>;
+export type CreateEmailDomainAclError = OvhOpError;
+/** Create new ACL */
+export declare const createEmailDomainAcl: API.OperationMethod<CreateEmailDomainAclRequest, EmailDomainAcl, CreateEmailDomainAclError, OvhOpContext>;
+export type CreateEmailDomainChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createEmailDomainChangeContact: API.OperationMethod<CreateEmailDomainChangeContactRequest, CreateEmailDomainChangeContactResponse, CreateEmailDomainChangeContactError, OvhOpContext>;
+export type CreateEmailDomainChangeDnsMXFilterError = OvhOpError;
+/** Change MX filter, so change MX DNS records */
+export declare const createEmailDomainChangeDnsMXFilter: API.OperationMethod<CreateEmailDomainChangeDnsMXFilterRequest, CreateEmailDomainChangeDnsMXFilterResponse, CreateEmailDomainChangeDnsMXFilterError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountChangePasswordError = OvhOpError;
+/** Change mailbox password (length : [9;30], no space at begin and end, no accent) */
+export declare const createEmailDomainDelegatedAccountChangePassword: API.OperationMethod<CreateEmailDomainDelegatedAccountChangePasswordRequest, EmailDomainTaskPop, CreateEmailDomainDelegatedAccountChangePasswordError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountFilterError = OvhOpError;
+/** Create new filter for account */
+export declare const createEmailDomainDelegatedAccountFilter: API.OperationMethod<CreateEmailDomainDelegatedAccountFilterRequest, EmailDomainTaskFilter, CreateEmailDomainDelegatedAccountFilterError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountFilterChangeActivityError = OvhOpError;
+/** Change filter activity */
+export declare const createEmailDomainDelegatedAccountFilterChangeActivity: API.OperationMethod<CreateEmailDomainDelegatedAccountFilterChangeActivityRequest, EmailDomainTaskFilter, CreateEmailDomainDelegatedAccountFilterChangeActivityError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountFilterChangePriorityError = OvhOpError;
+/** Change filter priority */
+export declare const createEmailDomainDelegatedAccountFilterChangePriority: API.OperationMethod<CreateEmailDomainDelegatedAccountFilterChangePriorityRequest, EmailDomainTaskFilter, CreateEmailDomainDelegatedAccountFilterChangePriorityError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountFilterRuleError = OvhOpError;
+/** Create new rule for filter */
+export declare const createEmailDomainDelegatedAccountFilterRule: API.OperationMethod<CreateEmailDomainDelegatedAccountFilterRuleRequest, EmailDomainTaskFilter, CreateEmailDomainDelegatedAccountFilterRuleError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountResponderError = OvhOpError;
+/** Create new responder in server */
+export declare const createEmailDomainDelegatedAccountResponder: API.OperationMethod<CreateEmailDomainDelegatedAccountResponderRequest, EmailDomainTaskSpecialAccount, CreateEmailDomainDelegatedAccountResponderError, OvhOpContext>;
+export type CreateEmailDomainDelegatedAccountUsageError = OvhOpError;
+/** usage of account */
+export declare const createEmailDomainDelegatedAccountUsage: API.OperationMethod<CreateEmailDomainDelegatedAccountUsageRequest, DomainDomainUsageAccountStruct, CreateEmailDomainDelegatedAccountUsageError, OvhOpContext>;
+export type CreateEmailDomainMailingListError = OvhOpError;
+/** Create new mailingList */
+export declare const createEmailDomainMailingList: API.OperationMethod<CreateEmailDomainMailingListRequest, EmailDomainTaskMl, CreateEmailDomainMailingListError, OvhOpContext>;
+export type CreateEmailDomainMailingListChangeOptionError = OvhOpError;
+/** Change mailing list options */
+export declare const createEmailDomainMailingListChangeOption: API.OperationMethod<CreateEmailDomainMailingListChangeOptionRequest, EmailDomainTaskMl, CreateEmailDomainMailingListChangeOptionError, OvhOpContext>;
+export type CreateEmailDomainMailingListModeratorError = OvhOpError;
+/** Add moderator to mailing list */
+export declare const createEmailDomainMailingListModerator: API.OperationMethod<CreateEmailDomainMailingListModeratorRequest, EmailDomainTaskMl, CreateEmailDomainMailingListModeratorError, OvhOpContext>;
+export type CreateEmailDomainMailingListSubscriberError = OvhOpError;
+/** Add subscriber to mailing list */
+export declare const createEmailDomainMailingListSubscriber: API.OperationMethod<CreateEmailDomainMailingListSubscriberRequest, EmailDomainTaskMl, CreateEmailDomainMailingListSubscriberError, OvhOpContext>;
+export type CreateEmailDomainRedirectionError = OvhOpError;
+/** Create new redirection in server */
+export declare const createEmailDomainRedirection: API.OperationMethod<CreateEmailDomainRedirectionRequest, EmailDomainTaskSpecialAccount, CreateEmailDomainRedirectionError, OvhOpContext>;
+export type CreateEmailDomainRedirectionChangeRedirectionError = OvhOpError;
+/** Change redirection */
+export declare const createEmailDomainRedirectionChangeRedirection: API.OperationMethod<CreateEmailDomainRedirectionChangeRedirectionRequest, EmailDomainTaskSpecialAccount, CreateEmailDomainRedirectionChangeRedirectionError, OvhOpContext>;
+export type CreateEmailDomainResponderError = OvhOpError;
+/** Create new responder in server */
+export declare const createEmailDomainResponder: API.OperationMethod<CreateEmailDomainResponderRequest, EmailDomainTaskSpecialAccount, CreateEmailDomainResponderError, OvhOpContext>;
+export type DeleteEmailDomainAccountError = OvhOpError;
+/** Delete an existing mailbox in server */
+export declare const deleteEmailDomainAccount: API.OperationMethod<DeleteEmailDomainAccountRequest, EmailDomainTaskPop, DeleteEmailDomainAccountError, OvhOpContext>;
+export type DeleteEmailDomainAccountDelegationError = OvhOpError;
+/** Delete an existing delegation */
+export declare const deleteEmailDomainAccountDelegation: API.OperationMethod<DeleteEmailDomainAccountDelegationRequest, DeleteEmailDomainAccountDelegationResponse, DeleteEmailDomainAccountDelegationError, OvhOpContext>;
+export type DeleteEmailDomainAccountFilterError = OvhOpError;
+/** Delete an existing filter */
+export declare const deleteEmailDomainAccountFilter: API.OperationMethod<DeleteEmailDomainAccountFilterRequest, DeleteEmailDomainAccountFilterResponse, DeleteEmailDomainAccountFilterError, OvhOpContext>;
+export type DeleteEmailDomainAccountFilterRuleError = OvhOpError;
+/** Delete an existing filter */
+export declare const deleteEmailDomainAccountFilterRule: API.OperationMethod<DeleteEmailDomainAccountFilterRuleRequest, DeleteEmailDomainAccountFilterRuleResponse, DeleteEmailDomainAccountFilterRuleError, OvhOpContext>;
+export type DeleteEmailDomainAclError = OvhOpError;
+/** Delete ACL */
+export declare const deleteEmailDomainAcl: API.OperationMethod<DeleteEmailDomainAclRequest, DeleteEmailDomainAclResponse, DeleteEmailDomainAclError, OvhOpContext>;
+export type DeleteEmailDomainDelegatedAccountFilterError = OvhOpError;
+/** Delete an existing filter */
+export declare const deleteEmailDomainDelegatedAccountFilter: API.OperationMethod<DeleteEmailDomainDelegatedAccountFilterRequest, DeleteEmailDomainDelegatedAccountFilterResponse, DeleteEmailDomainDelegatedAccountFilterError, OvhOpContext>;
+export type DeleteEmailDomainDelegatedAccountFilterRuleError = OvhOpError;
+/** Delete an existing filter */
+export declare const deleteEmailDomainDelegatedAccountFilterRule: API.OperationMethod<DeleteEmailDomainDelegatedAccountFilterRuleRequest, DeleteEmailDomainDelegatedAccountFilterRuleResponse, DeleteEmailDomainDelegatedAccountFilterRuleError, OvhOpContext>;
+export type DeleteEmailDomainDelegatedAccountResponderError = OvhOpError;
+/** Delete an existing responder in server */
+export declare const deleteEmailDomainDelegatedAccountResponder: API.OperationMethod<DeleteEmailDomainDelegatedAccountResponderRequest, EmailDomainTaskSpecialAccount, DeleteEmailDomainDelegatedAccountResponderError, OvhOpContext>;
+export type DeleteEmailDomainMailingListError = OvhOpError;
+/** Delete existing Mailing list */
+export declare const deleteEmailDomainMailingList: API.OperationMethod<DeleteEmailDomainMailingListRequest, EmailDomainTaskMl, DeleteEmailDomainMailingListError, OvhOpContext>;
+export type DeleteEmailDomainMailingListModeratorError = OvhOpError;
+/** Delete existing moderator */
+export declare const deleteEmailDomainMailingListModerator: API.OperationMethod<DeleteEmailDomainMailingListModeratorRequest, EmailDomainTaskMl, DeleteEmailDomainMailingListModeratorError, OvhOpContext>;
+export type DeleteEmailDomainMailingListSubscriberError = OvhOpError;
+/** Delete existing subscriber */
+export declare const deleteEmailDomainMailingListSubscriber: API.OperationMethod<DeleteEmailDomainMailingListSubscriberRequest, EmailDomainTaskMl, DeleteEmailDomainMailingListSubscriberError, OvhOpContext>;
+export type DeleteEmailDomainRedirectionError = OvhOpError;
+/** Delete an existing redirection in server */
+export declare const deleteEmailDomainRedirection: API.OperationMethod<DeleteEmailDomainRedirectionRequest, EmailDomainTaskSpecialAccount, DeleteEmailDomainRedirectionError, OvhOpContext>;
+export type DeleteEmailDomainResponderError = OvhOpError;
+/** Delete an existing responder in server */
+export declare const deleteEmailDomainResponder: API.OperationMethod<DeleteEmailDomainResponderRequest, EmailDomainTaskSpecialAccount, DeleteEmailDomainResponderError, OvhOpContext>;
+export type GetEmailDomainError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomain: API.OperationMethod<GetEmailDomainRequest, EmailDomainDomainServiceWithIAM, GetEmailDomainError, OvhOpContext>;
+export type GetEmailDomainAccountError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAccount: API.OperationMethod<GetEmailDomainAccountRequest, EmailDomainAccount, GetEmailDomainAccountError, OvhOpContext>;
+export type GetEmailDomainAccountDelegationError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAccountDelegation: API.OperationMethod<GetEmailDomainAccountDelegationRequest, EmailDomainDelegation, GetEmailDomainAccountDelegationError, OvhOpContext>;
+export type GetEmailDomainAccountFilterError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAccountFilter: API.OperationMethod<GetEmailDomainAccountFilterRequest, EmailDomainFilter, GetEmailDomainAccountFilterError, OvhOpContext>;
+export type GetEmailDomainAccountFilterRuleError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAccountFilterRule: API.OperationMethod<GetEmailDomainAccountFilterRuleRequest, EmailDomainRule, GetEmailDomainAccountFilterRuleError, OvhOpContext>;
+export type GetEmailDomainAccountMigrateError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAccountMigrate: API.OperationMethod<GetEmailDomainAccountMigrateRequest, EmailDomainMigrationService, GetEmailDomainAccountMigrateError, OvhOpContext>;
+export type GetEmailDomainAccountMigrateDestinationEmailAddressError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAccountMigrateDestinationEmailAddress: API.OperationMethod<GetEmailDomainAccountMigrateDestinationEmailAddressRequest, EmailDomainMigrationAccount, GetEmailDomainAccountMigrateDestinationEmailAddressError, OvhOpContext>;
+export type GetEmailDomainAccountUsageError = OvhOpError;
+/** usage of account */
+export declare const getEmailDomainAccountUsage: API.OperationMethod<GetEmailDomainAccountUsageRequest, DomainDomainUsageAccountStruct, GetEmailDomainAccountUsageError, OvhOpContext>;
+export type GetEmailDomainAclError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainAcl: API.OperationMethod<GetEmailDomainAclRequest, EmailDomainAcl, GetEmailDomainAclError, OvhOpContext>;
+export type GetEmailDomainDelegatedAccountError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainDelegatedAccount: API.OperationMethod<GetEmailDomainDelegatedAccountRequest, EmailDomainAccountDelegated, GetEmailDomainDelegatedAccountError, OvhOpContext>;
+export type GetEmailDomainDelegatedAccountFilterError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainDelegatedAccountFilter: API.OperationMethod<GetEmailDomainDelegatedAccountFilterRequest, EmailDomainFilter, GetEmailDomainDelegatedAccountFilterError, OvhOpContext>;
+export type GetEmailDomainDelegatedAccountFilterRuleError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainDelegatedAccountFilterRule: API.OperationMethod<GetEmailDomainDelegatedAccountFilterRuleRequest, EmailDomainRule, GetEmailDomainDelegatedAccountFilterRuleError, OvhOpContext>;
+export type GetEmailDomainDelegatedAccountResponderError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainDelegatedAccountResponder: API.OperationMethod<GetEmailDomainDelegatedAccountResponderRequest, EmailDomainResponderAccount, GetEmailDomainDelegatedAccountResponderError, OvhOpContext>;
+export type GetEmailDomainDnsMXFilterError = OvhOpError;
+/** Domain MX filter */
+export declare const getEmailDomainDnsMXFilter: API.OperationMethod<GetEmailDomainDnsMXFilterRequest, GetEmailDomainDnsMXFilterResponse, GetEmailDomainDnsMXFilterError, OvhOpContext>;
+export type GetEmailDomainMailingListError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainMailingList: API.OperationMethod<GetEmailDomainMailingListRequest, EmailDomainMailingList, GetEmailDomainMailingListError, OvhOpContext>;
+export type GetEmailDomainMailingListLimitsError = OvhOpError;
+/** Get limits of mailing list */
+export declare const getEmailDomainMailingListLimits: API.OperationMethod<GetEmailDomainMailingListLimitsRequest, DomainDomainMlLimits, GetEmailDomainMailingListLimitsError, OvhOpContext>;
+export type GetEmailDomainMailingListModeratorError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainMailingListModerator: API.OperationMethod<GetEmailDomainMailingListModeratorRequest, EmailDomainModerator, GetEmailDomainMailingListModeratorError, OvhOpContext>;
+export type GetEmailDomainMailingListSubscriberError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainMailingListSubscriber: API.OperationMethod<GetEmailDomainMailingListSubscriberRequest, EmailDomainSubscriber, GetEmailDomainMailingListSubscriberError, OvhOpContext>;
+export type GetEmailDomainQuotaError = OvhOpError;
+/** List all quotas for this domain */
+export declare const getEmailDomainQuota: API.OperationMethod<GetEmailDomainQuotaRequest, DomainDomainQuota, GetEmailDomainQuotaError, OvhOpContext>;
+export type GetEmailDomainRedirectionError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainRedirection: API.OperationMethod<GetEmailDomainRedirectionRequest, EmailDomainRedirectionGlobal, GetEmailDomainRedirectionError, OvhOpContext>;
+export type GetEmailDomainResponderError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainResponder: API.OperationMethod<GetEmailDomainResponderRequest, EmailDomainResponder, GetEmailDomainResponderError, OvhOpContext>;
+export type GetEmailDomainServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getEmailDomainServiceInfos: API.OperationMethod<GetEmailDomainServiceInfosRequest, ServicesService, GetEmailDomainServiceInfosError, OvhOpContext>;
+export type GetEmailDomainSummaryError = OvhOpError;
+/** Summary for this domain */
+export declare const getEmailDomainSummary: API.OperationMethod<GetEmailDomainSummaryRequest, DomainDomainSummary, GetEmailDomainSummaryError, OvhOpContext>;
+export type GetEmailDomainTaskAccountError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainTaskAccount: API.OperationMethod<GetEmailDomainTaskAccountRequest, EmailDomainTaskPop, GetEmailDomainTaskAccountError, OvhOpContext>;
+export type GetEmailDomainTaskAllError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainTaskAll: API.OperationMethod<GetEmailDomainTaskAllRequest, EmailDomainTask, GetEmailDomainTaskAllError, OvhOpContext>;
+export type GetEmailDomainTaskFilterError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainTaskFilter: API.OperationMethod<GetEmailDomainTaskFilterRequest, EmailDomainTaskFilter, GetEmailDomainTaskFilterError, OvhOpContext>;
+export type GetEmailDomainTaskMailinglistError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainTaskMailinglist: API.OperationMethod<GetEmailDomainTaskMailinglistRequest, EmailDomainTaskMl, GetEmailDomainTaskMailinglistError, OvhOpContext>;
+export type GetEmailDomainTaskRedirectionError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainTaskRedirection: API.OperationMethod<GetEmailDomainTaskRedirectionRequest, EmailDomainTaskSpecialAccount, GetEmailDomainTaskRedirectionError, OvhOpContext>;
+export type GetEmailDomainTaskResponderError = OvhOpError;
+/** Get this object properties */
+export declare const getEmailDomainTaskResponder: API.OperationMethod<GetEmailDomainTaskResponderRequest, EmailDomainTaskSpecialAccount, GetEmailDomainTaskResponderError, OvhOpContext>;
+export type ListEmailDomainError = OvhOpError;
+/** List available services */
+export declare const listEmailDomain: API.OperationMethod<ListEmailDomainRequest, ListEmailDomainResponse, ListEmailDomainError, OvhOpContext>;
+export type ListEmailDomainAccountError = OvhOpError;
+/** Get accounts */
+export declare const listEmailDomainAccount: API.OperationMethod<ListEmailDomainAccountRequest, ListEmailDomainAccountResponse, ListEmailDomainAccountError, OvhOpContext>;
+export type ListEmailDomainAccountDelegationError = OvhOpError;
+/** Get delegations */
+export declare const listEmailDomainAccountDelegation: API.OperationMethod<ListEmailDomainAccountDelegationRequest, ListEmailDomainAccountDelegationResponse, ListEmailDomainAccountDelegationError, OvhOpContext>;
+export type ListEmailDomainAccountFilterError = OvhOpError;
+/** Get filters */
+export declare const listEmailDomainAccountFilter: API.OperationMethod<ListEmailDomainAccountFilterRequest, ListEmailDomainAccountFilterResponse, ListEmailDomainAccountFilterError, OvhOpContext>;
+export type ListEmailDomainAccountFilterRuleError = OvhOpError;
+/** Get rules */
+export declare const listEmailDomainAccountFilterRule: API.OperationMethod<ListEmailDomainAccountFilterRuleRequest, ListEmailDomainAccountFilterRuleResponse, ListEmailDomainAccountFilterRuleError, OvhOpContext>;
+export type ListEmailDomainAccountMigrateError = OvhOpError;
+/** Get migration service */
+export declare const listEmailDomainAccountMigrate: API.OperationMethod<ListEmailDomainAccountMigrateRequest, ListEmailDomainAccountMigrateResponse, ListEmailDomainAccountMigrateError, OvhOpContext>;
+export type ListEmailDomainAccountMigrateDestinationEmailAddressError = OvhOpError;
+/** List of email address available for migration */
+export declare const listEmailDomainAccountMigrateDestinationEmailAddress: API.OperationMethod<ListEmailDomainAccountMigrateDestinationEmailAddressRequest, ListEmailDomainAccountMigrateDestinationEmailAddressResponse, ListEmailDomainAccountMigrateDestinationEmailAddressError, OvhOpContext>;
+export type ListEmailDomainAccountMigrateDestinationEmailAddressCheckMigrateError = OvhOpError;
+/** Check if it's possible to migrate */
+export declare const listEmailDomainAccountMigrateDestinationEmailAddressCheckMigrate: API.OperationMethod<ListEmailDomainAccountMigrateDestinationEmailAddressCheckMigrateRequest, EmailDomainMigrationCheckStruct, ListEmailDomainAccountMigrateDestinationEmailAddressCheckMigrateError, OvhOpContext>;
+export type ListEmailDomainAclError = OvhOpError;
+/** Get ACL on your domain */
+export declare const listEmailDomainAcl: API.OperationMethod<ListEmailDomainAclRequest, ListEmailDomainAclResponse, ListEmailDomainAclError, OvhOpContext>;
+export type ListEmailDomainDelegatedAccountError = OvhOpError;
+/** Delegated emails */
+export declare const listEmailDomainDelegatedAccount: API.OperationMethod<ListEmailDomainDelegatedAccountRequest, ListEmailDomainDelegatedAccountResponse, ListEmailDomainDelegatedAccountError, OvhOpContext>;
+export type ListEmailDomainDelegatedAccountFilterError = OvhOpError;
+/** Get filters */
+export declare const listEmailDomainDelegatedAccountFilter: API.OperationMethod<ListEmailDomainDelegatedAccountFilterRequest, ListEmailDomainDelegatedAccountFilterResponse, ListEmailDomainDelegatedAccountFilterError, OvhOpContext>;
+export type ListEmailDomainDelegatedAccountFilterRuleError = OvhOpError;
+/** Get rules */
+export declare const listEmailDomainDelegatedAccountFilterRule: API.OperationMethod<ListEmailDomainDelegatedAccountFilterRuleRequest, ListEmailDomainDelegatedAccountFilterRuleResponse, ListEmailDomainDelegatedAccountFilterRuleError, OvhOpContext>;
+export type ListEmailDomainDkimError = OvhOpError;
+/** Get this object properties */
+export declare const listEmailDomainDkim: API.OperationMethod<ListEmailDomainDkimRequest, EmailDomainDkimSimplified, ListEmailDomainDkimError, OvhOpContext>;
+export type ListEmailDomainDnsMXRecordsError = OvhOpError;
+/** Domain MX records */
+export declare const listEmailDomainDnsMXRecords: API.OperationMethod<ListEmailDomainDnsMXRecordsRequest, ListEmailDomainDnsMXRecordsResponse, ListEmailDomainDnsMXRecordsError, OvhOpContext>;
+export type ListEmailDomainMailingListError = OvhOpError;
+/** Get mailing lists */
+export declare const listEmailDomainMailingList: API.OperationMethod<ListEmailDomainMailingListRequest, ListEmailDomainMailingListResponse, ListEmailDomainMailingListError, OvhOpContext>;
+export type ListEmailDomainMailingListModeratorError = OvhOpError;
+/** List of moderators */
+export declare const listEmailDomainMailingListModerator: API.OperationMethod<ListEmailDomainMailingListModeratorRequest, ListEmailDomainMailingListModeratorResponse, ListEmailDomainMailingListModeratorError, OvhOpContext>;
+export type ListEmailDomainMailingListSubscriberError = OvhOpError;
+/** List of subscribers */
+export declare const listEmailDomainMailingListSubscriber: API.OperationMethod<ListEmailDomainMailingListSubscriberRequest, ListEmailDomainMailingListSubscriberResponse, ListEmailDomainMailingListSubscriberError, OvhOpContext>;
+export type ListEmailDomainRecommendedDNSRecordsError = OvhOpError;
+/** Recommended domain DNS records */
+export declare const listEmailDomainRecommendedDNSRecords: API.OperationMethod<ListEmailDomainRecommendedDNSRecordsRequest, ListEmailDomainRecommendedDNSRecordsResponse, ListEmailDomainRecommendedDNSRecordsError, OvhOpContext>;
+export type ListEmailDomainRedirectionError = OvhOpError;
+/** Get redirections */
+export declare const listEmailDomainRedirection: API.OperationMethod<ListEmailDomainRedirectionRequest, ListEmailDomainRedirectionResponse, ListEmailDomainRedirectionError, OvhOpContext>;
+export type ListEmailDomainResponderError = OvhOpError;
+/** Get responders */
+export declare const listEmailDomainResponder: API.OperationMethod<ListEmailDomainResponderRequest, ListEmailDomainResponderResponse, ListEmailDomainResponderError, OvhOpContext>;
+export type ListEmailDomainTaskAccountError = OvhOpError;
+/** Get account tasks */
+export declare const listEmailDomainTaskAccount: API.OperationMethod<ListEmailDomainTaskAccountRequest, ListEmailDomainTaskAccountResponse, ListEmailDomainTaskAccountError, OvhOpContext>;
+export type ListEmailDomainTaskAllError = OvhOpError;
+/** Get tasks */
+export declare const listEmailDomainTaskAll: API.OperationMethod<ListEmailDomainTaskAllRequest, ListEmailDomainTaskAllResponse, ListEmailDomainTaskAllError, OvhOpContext>;
+export type ListEmailDomainTaskFilterError = OvhOpError;
+/** Get filter tasks */
+export declare const listEmailDomainTaskFilter: API.OperationMethod<ListEmailDomainTaskFilterRequest, ListEmailDomainTaskFilterResponse, ListEmailDomainTaskFilterError, OvhOpContext>;
+export type ListEmailDomainTaskMailinglistError = OvhOpError;
+/** Get Mailing List tasks */
+export declare const listEmailDomainTaskMailinglist: API.OperationMethod<ListEmailDomainTaskMailinglistRequest, ListEmailDomainTaskMailinglistResponse, ListEmailDomainTaskMailinglistError, OvhOpContext>;
+export type ListEmailDomainTaskRedirectionError = OvhOpError;
+/** Get redirection tasks */
+export declare const listEmailDomainTaskRedirection: API.OperationMethod<ListEmailDomainTaskRedirectionRequest, ListEmailDomainTaskRedirectionResponse, ListEmailDomainTaskRedirectionError, OvhOpContext>;
+export type ListEmailDomainTaskResponderError = OvhOpError;
+/** Get responder tasks */
+export declare const listEmailDomainTaskResponder: API.OperationMethod<ListEmailDomainTaskResponderRequest, ListEmailDomainTaskResponderResponse, ListEmailDomainTaskResponderError, OvhOpContext>;
+export type MigrateEmailDomainAccountMigrateDestinationEmailAddressError = OvhOpError;
+/** Migrate account to destination account */
+export declare const migrateEmailDomainAccountMigrateDestinationEmailAddress: API.OperationMethod<MigrateEmailDomainAccountMigrateDestinationEmailAddressRequest, EmailDomainTaskPop, MigrateEmailDomainAccountMigrateDestinationEmailAddressError, OvhOpContext>;
+export type MigrateEmailDomainDelegationV3toV6Error = OvhOpError;
+/** Create delegation of domain with same nic than V3 */
+export declare const migrateEmailDomainDelegationV3toV6: API.OperationMethod<MigrateEmailDomainDelegationV3toV6Request, MigrateEmailDomainDelegationV3toV6Response, MigrateEmailDomainDelegationV3toV6Error, OvhOpContext>;
+export type PutEmailDomainAccountError = OvhOpError;
+/** Alter this object properties */
+export declare const putEmailDomainAccount: API.OperationMethod<PutEmailDomainAccountRequest, PutEmailDomainAccountResponse, PutEmailDomainAccountError, OvhOpContext>;
+export type PutEmailDomainDelegatedAccountError = OvhOpError;
+/** Alter this object properties */
+export declare const putEmailDomainDelegatedAccount: API.OperationMethod<PutEmailDomainDelegatedAccountRequest, PutEmailDomainDelegatedAccountResponse, PutEmailDomainDelegatedAccountError, OvhOpContext>;
+export type PutEmailDomainDelegatedAccountResponderError = OvhOpError;
+/** Alter this object properties */
+export declare const putEmailDomainDelegatedAccountResponder: API.OperationMethod<PutEmailDomainDelegatedAccountResponderRequest, PutEmailDomainDelegatedAccountResponderResponse, PutEmailDomainDelegatedAccountResponderError, OvhOpContext>;
+export type PutEmailDomainDkimDisableError = OvhOpError;
+/** Disable DKIM */
+export declare const putEmailDomainDkimDisable: API.OperationMethod<PutEmailDomainDkimDisableRequest, EmailDomainTask, PutEmailDomainDkimDisableError, OvhOpContext>;
+export type PutEmailDomainDkimEnableError = OvhOpError;
+/** Enable DKIM */
+export declare const putEmailDomainDkimEnable: API.OperationMethod<PutEmailDomainDkimEnableRequest, EmailDomainTask, PutEmailDomainDkimEnableError, OvhOpContext>;
+export type PutEmailDomainMailingListError = OvhOpError;
+/** Alter this object properties */
+export declare const putEmailDomainMailingList: API.OperationMethod<PutEmailDomainMailingListRequest, PutEmailDomainMailingListResponse, PutEmailDomainMailingListError, OvhOpContext>;
+export type PutEmailDomainResponderError = OvhOpError;
+/** Alter this object properties */
+export declare const putEmailDomainResponder: API.OperationMethod<PutEmailDomainResponderRequest, PutEmailDomainResponderResponse, PutEmailDomainResponderError, OvhOpContext>;
+export type PutEmailDomainServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putEmailDomainServiceInfos: API.OperationMethod<PutEmailDomainServiceInfosRequest, PutEmailDomainServiceInfosResponse, PutEmailDomainServiceInfosError, OvhOpContext>;
+export type SendEmailDomainMailingListListByEmailError = OvhOpError;
+/** Send moderators list and subscribers list of this mailing list by email */
+export declare const sendEmailDomainMailingListListByEmail: API.OperationMethod<SendEmailDomainMailingListListByEmailRequest, EmailDomainTaskMl, SendEmailDomainMailingListListByEmailError, OvhOpContext>;
+export type TerminateEmailDomainError = OvhOpError;
+/** Terminate your email service */
+export declare const terminateEmailDomain: API.OperationMethod<TerminateEmailDomainRequest, TerminateEmailDomainResponse, TerminateEmailDomainError, OvhOpContext>;
+export type UpdateEmailDomainAccountUsageError = OvhOpError;
+/** Update usage of account */
+export declare const updateEmailDomainAccountUsage: API.OperationMethod<UpdateEmailDomainAccountUsageRequest, UpdateEmailDomainAccountUsageResponse, UpdateEmailDomainAccountUsageError, OvhOpContext>;
+export type UpdateEmailDomainDelegatedAccountUsageError = OvhOpError;
+/** Update usage of account */
+export declare const updateEmailDomainDelegatedAccountUsage: API.OperationMethod<UpdateEmailDomainDelegatedAccountUsageRequest, UpdateEmailDomainDelegatedAccountUsageResponse, UpdateEmailDomainDelegatedAccountUsageError, OvhOpContext>;
+//# sourceMappingURL=emaildomain.d.ts.map