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

package/src/services/emailpro.ts

@@ -0,0 +1,3519 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-ovh). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  OvhProtocol,
+  type OvhOpError,
+  type OvhOpContext,
+} from "../protocol.ts";
+import { UnknownOvhError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { OvhOpError, OvhOpContext };
+
+export interface CreateEmailProAccountAliasRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Alias */
+  alias: string;
+}
+export const CreateEmailProAccountAliasRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    alias: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/account/{email}/alias",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateEmailProAccountAliasRequest",
+}) as any as S.Schema<CreateEmailProAccountAliasRequest>;
+
+/** function enumeration for task */
+export type EmailProTaskFunctionEnum =
+  | "addAccount"
+  | "addAlias"
+  | "addDomain"
+  | "addDomainDKIM"
+  | "addDomainDisclaimer"
+  | "addExternalContact"
+  | "addFullAccess"
+  | "addSendAs"
+  | "addSendOnBehalfTo"
+  | "addServiceAuthorizedIp"
+  | "changeHostname"
+  | "changePassword"
+  | "configureCustomer"
+  | "deleteAccount"
+  | "deleteAlias"
+  | "deleteDomain"
+  | "deleteDomainDKIM"
+  | "deleteDomainDisclaimer"
+  | "deleteExternalContact"
+  | "deleteFullAccess"
+  | "deleteSendAs"
+  | "deleteSendOnBehalfTo"
+  | "deleteService"
+  | "deleteServiceAuthorizedIp"
+  | "diagnoseAccount"
+  | "disableDKIM"
+  | "enableDKIM"
+  | "expandDrive"
+  | "installServer"
+  | "maintenance"
+  | "migrateAccountViaOMM"
+  | "migrationAccount"
+  | "migrationDisclaimer"
+  | "migrationExternalContact"
+  | "migrationHistory"
+  | "migrationService"
+  | "reOpenAccount"
+  | "setAccount"
+  | "setAlias"
+  | "setDns"
+  | "setDomain"
+  | "setDomainDisclaimer"
+  | "setExternalContact"
+  | "setService"
+  | "suspendAccount"
+  | "suspendService"
+  | "unknown"
+  | "unsuspendAccount"
+  | "unsuspendService";
+export const EmailProTaskFunctionEnum = /*@__PURE__*/ S.String;
+
+/** Task status */
+export type EmailProTaskStatusEnum =
+  | "cancelled"
+  | "doing"
+  | "done"
+  | "error"
+  | "todo";
+export const EmailProTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** Organization task details */
+export interface EmailProTask {
+  /** Completion date */
+  finishDate?: string | null;
+  /** Function name */
+  function?: EmailProTaskFunctionEnum;
+  /** Task id */
+  id?: number;
+  /** Task status */
+  status?: EmailProTaskStatusEnum;
+  /** Creation date */
+  todoDate?: string;
+}
+export const EmailProTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    finishDate: S.optional(S.NullOr(S.String)),
+    function: S.optional(EmailProTaskFunctionEnum),
+    id: S.optional(S.Number),
+    status: S.optional(EmailProTaskStatusEnum),
+    todoDate: S.optional(S.String),
+  }),
+).annotate({ identifier: "EmailProTask" }) as any as S.Schema<EmailProTask>;
+
+export interface CreateEmailProAccountChangePasswordRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** new password */
+  password: string | Redacted.Redacted<string>;
+}
+export const CreateEmailProAccountChangePasswordRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      password: S.String.pipe(T.SensitiveValue({})),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/account/{email}/changePassword",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateEmailProAccountChangePasswordRequest",
+  }) as any as S.Schema<CreateEmailProAccountChangePasswordRequest>;
+
+export interface CreateEmailProAccountDiagnosticRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account password */
+  password: string | Redacted.Redacted<string>;
+}
+export const CreateEmailProAccountDiagnosticRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      password: S.String.pipe(T.SensitiveValue({})),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/account/{email}/diagnostics",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailProAccountDiagnosticRequest",
+}) as any as S.Schema<CreateEmailProAccountDiagnosticRequest>;
+
+export interface CreateEmailProAccountFullAccessRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** User to give full access */
+  allowedAccountId: number;
+}
+export const CreateEmailProAccountFullAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      allowedAccountId: S.Number,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/account/{email}/fullAccess",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailProAccountFullAccessRequest",
+}) as any as S.Schema<CreateEmailProAccountFullAccessRequest>;
+
+export interface CreateEmailProChangeContactRequest {
+  /** The internal name of your pro organization */
+  service: 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 const CreateEmailProChangeContactRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    contactAdmin: S.optional(S.String),
+    contactBilling: S.optional(S.String),
+    contactTech: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/changeContact",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateEmailProChangeContactRequest",
+}) as any as S.Schema<CreateEmailProChangeContactRequest>;
+
+export type CreateEmailProChangeContactResponseBodyList = Array<number>;
+export const CreateEmailProChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateEmailProChangeContactResponseBodyList>;
+
+export type CreateEmailProChangeContactResponse =
+  CreateEmailProChangeContactResponseBodyList;
+export const CreateEmailProChangeContactResponse = /*@__PURE__*/ S.suspend(() =>
+  CreateEmailProChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateEmailProChangeContactResponse",
+}) as any as S.Schema<CreateEmailProChangeContactResponse>;
+
+/** Domain type */
+export type EmailProDomainTypeEnum = "authoritative" | "nonAuthoritative";
+export const EmailProDomainTypeEnum = /*@__PURE__*/ S.String;
+
+export interface CreateEmailProDomainRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Enable DKIM automatically after DKIM configuration */
+  autoEnableDKIM?: boolean;
+  /** If you host domain in OVH we can configure autodiscover record automatically */
+  configureAutodiscover?: boolean;
+  /** Launch configuration of DKIM automatically for the domain */
+  configureDKIM?: boolean;
+  /** If you host domain in OVH we can configure mx record automatically */
+  configureMx?: boolean;
+  /** Enable automatic SPF record (only for domains hosted by OVHcloud) */
+  configureSPF?: boolean;
+  /** If specified, emails to not existing address will be redirected to that domain */
+  mxRelay?: string;
+  /** Domain to install on server */
+  name: string;
+  /** Type of domain that You want to install */
+  type: EmailProDomainTypeEnum | (string & {});
+}
+export const CreateEmailProDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    autoEnableDKIM: S.optional(S.Boolean),
+    configureAutodiscover: S.optional(S.Boolean),
+    configureDKIM: S.optional(S.Boolean),
+    configureMx: S.optional(S.Boolean),
+    configureSPF: S.optional(S.Boolean),
+    mxRelay: S.optional(S.String),
+    name: S.String,
+    type: EmailProDomainTypeEnum,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/email/pro/{service}/domain", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateEmailProDomainRequest",
+}) as any as S.Schema<CreateEmailProDomainRequest>;
+
+export interface CreateEmailProDomainDisclaimerRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** Signature, added at the bottom of your organization emails */
+  content: string;
+  /** Activate the disclaimer only for external emails */
+  outsideOnly?: boolean;
+}
+export const CreateEmailProDomainDisclaimerRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+      content: S.String,
+      outsideOnly: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/domain/{domainName}/disclaimer",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailProDomainDisclaimerRequest",
+}) as any as S.Schema<CreateEmailProDomainDisclaimerRequest>;
+
+export interface CreateEmailProDomainDkimRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** Enable DKIM automatically after DKIM configuration */
+  autoEnableDKIM?: boolean;
+  /** If you host domain in OVH we can configure dkim dns record automatically */
+  configureDkim?: boolean;
+  /** selector name for DKIM */
+  selectorName: string;
+}
+export const CreateEmailProDomainDkimRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    autoEnableDKIM: S.optional(S.Boolean),
+    configureDkim: S.optional(S.Boolean),
+    selectorName: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/domain/{domainName}/dkim",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateEmailProDomainDkimRequest",
+}) as any as S.Schema<CreateEmailProDomainDkimRequest>;
+
+export interface CreateEmailProExternalContactRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Contact display name */
+  displayName?: string;
+  /** Contact email address */
+  externalEmailAddress: string;
+  /** Contact first name */
+  firstName?: string;
+  /** Hide the contact in Global Address List */
+  hiddenFromGAL?: boolean;
+  /** Contact initials */
+  initials?: string;
+  /** Contact last name */
+  lastName?: string;
+}
+export const CreateEmailProExternalContactRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      displayName: S.optional(S.String),
+      externalEmailAddress: S.String,
+      firstName: S.optional(S.String),
+      hiddenFromGAL: S.optional(S.Boolean),
+      initials: S.optional(S.String),
+      lastName: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/externalContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailProExternalContactRequest",
+}) as any as S.Schema<CreateEmailProExternalContactRequest>;
+
+export interface DeleteEmailProAccountRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const DeleteEmailProAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/email/pro/{service}/account/{email}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteEmailProAccountRequest",
+}) as any as S.Schema<DeleteEmailProAccountRequest>;
+
+export interface DeleteEmailProAccountAliasRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Alias */
+  alias: string;
+}
+export const DeleteEmailProAccountAliasRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    alias: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/email/pro/{service}/account/{email}/alias/{alias}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteEmailProAccountAliasRequest",
+}) as any as S.Schema<DeleteEmailProAccountAliasRequest>;
+
+export interface DeleteEmailProAccountFullAccessRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give full access */
+  allowedAccountId: number;
+}
+export const DeleteEmailProAccountFullAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      allowedAccountId: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/email/pro/{service}/account/{email}/fullAccess/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailProAccountFullAccessRequest",
+}) as any as S.Schema<DeleteEmailProAccountFullAccessRequest>;
+
+export interface DeleteEmailProAccountSendAsRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give send as */
+  allowedAccountId: number;
+}
+export const DeleteEmailProAccountSendAsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    allowedAccountId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/email/pro/{service}/account/{email}/sendAs/{allowedAccountId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteEmailProAccountSendAsRequest",
+}) as any as S.Schema<DeleteEmailProAccountSendAsRequest>;
+
+export interface DeleteEmailProAccountSendOnBehalfToRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give send on behalf to */
+  allowedAccountId: number;
+}
+export const DeleteEmailProAccountSendOnBehalfToRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      allowedAccountId: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/email/pro/{service}/account/{email}/sendOnBehalfTo/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteEmailProAccountSendOnBehalfToRequest",
+  }) as any as S.Schema<DeleteEmailProAccountSendOnBehalfToRequest>;
+
+export interface DeleteEmailProDomainRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const DeleteEmailProDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/email/pro/{service}/domain/{domainName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteEmailProDomainRequest",
+}) as any as S.Schema<DeleteEmailProDomainRequest>;
+
+export interface DeleteEmailProDomainDisclaimerRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const DeleteEmailProDomainDisclaimerRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/email/pro/{service}/domain/{domainName}/disclaimer",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailProDomainDisclaimerRequest",
+}) as any as S.Schema<DeleteEmailProDomainDisclaimerRequest>;
+
+export interface DeleteEmailProDomainDkimRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** selectorName */
+  selectorName: string;
+}
+export const DeleteEmailProDomainDkimRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    selectorName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/email/pro/{service}/domain/{domainName}/dkim/{selectorName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteEmailProDomainDkimRequest",
+}) as any as S.Schema<DeleteEmailProDomainDkimRequest>;
+
+export interface DeleteEmailProExternalContactRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Contact email */
+  externalEmailAddress: string;
+}
+export const DeleteEmailProExternalContactRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      externalEmailAddress: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/email/pro/{service}/externalContact/{externalEmailAddress}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailProExternalContactRequest",
+}) as any as S.Schema<DeleteEmailProExternalContactRequest>;
+
+export interface DisableEmailProDomainDkimRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** selectorName */
+  selectorName: string;
+}
+export const DisableEmailProDomainDkimRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    selectorName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/domain/{domainName}/dkim/{selectorName}/disable",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DisableEmailProDomainDkimRequest",
+}) as any as S.Schema<DisableEmailProDomainDkimRequest>;
+
+export interface EnableEmailProDomainDkimRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** selectorName */
+  selectorName: string;
+}
+export const EnableEmailProDomainDkimRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    selectorName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/domain/{domainName}/dkim/{selectorName}/enable",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EnableEmailProDomainDkimRequest",
+}) as any as S.Schema<EnableEmailProDomainDkimRequest>;
+
+export interface GetEmailProRequest {
+  /** Service */
+  service: string;
+}
+export const GetEmailProRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/email/pro/{service}", code: 200 })),
+).annotate({
+  identifier: "GetEmailProRequest",
+}) as any as S.Schema<GetEmailProRequest>;
+
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = { [key: string]: string | undefined };
+export const IamResourceMetadataTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as 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 tags. Tags that were internally computed are prefixed with ovh: */
+  tags?: IamResourceMetadataTagsMap | null;
+  /** Unique resource name used in policies */
+  urn?: string;
+}
+export const IamResourceMetadata = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.String),
+    tags: S.optional(S.NullOr(IamResourceMetadataTagsMap)),
+    urn: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "IamResourceMetadata",
+}) as any as S.Schema<IamResourceMetadata>;
+
+/** Service Offer name */
+export type EmailProServiceOfferEnum = "emailpro";
+export const EmailProServiceOfferEnum = /*@__PURE__*/ S.String;
+
+/** Spam and Antyvirus configuration */
+export interface EmailProSpamAndVirusConfiguration {
+  /** Check DKIM of message */
+  checkDKIM?: boolean;
+  /** Check SPF of message */
+  checkSPF?: boolean;
+  /** If message is a spam delete it */
+  deleteSpam?: boolean;
+  /** If message is a virus delete it */
+  deleteVirus?: boolean;
+  /** If message is a spam or virus put in junk. Overridden by deleteSpam or deleteVirus */
+  putInJunk?: boolean;
+  /** If message is a spam change its subject */
+  tagSpam?: boolean;
+  /** If message is a virus change its subject */
+  tagVirus?: boolean;
+}
+export const EmailProSpamAndVirusConfiguration = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    checkDKIM: S.optional(S.Boolean),
+    checkSPF: S.optional(S.Boolean),
+    deleteSpam: S.optional(S.Boolean),
+    deleteVirus: S.optional(S.Boolean),
+    putInJunk: S.optional(S.Boolean),
+    tagSpam: S.optional(S.Boolean),
+    tagVirus: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "EmailProSpamAndVirusConfiguration",
+}) as any as S.Schema<EmailProSpamAndVirusConfiguration>;
+
+/** Service State */
+export type EmailProServiceStateEnum =
+  | "creating"
+  | "deleting"
+  | "inMaintenance"
+  | "ok"
+  | "reopening"
+  | "suspended"
+  | "suspending";
+export const EmailProServiceStateEnum = /*@__PURE__*/ S.String;
+
+/** Email pro service */
+export interface EmailProServiceNativeWithIAM {
+  /** enable policy for strong and secure passwords */
+  complexityEnabled?: boolean;
+  /** service displayName */
+  displayName?: string | null;
+  /** Domain name of your service */
+  domain?: string;
+  /** Hostname of your service */
+  hostname?: string | null;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Update date */
+  lastUpdateDate?: string | null;
+  /** number of minutes account will remain locked if it occurs */
+  lockoutDuration?: number;
+  /** number of minutes that must elapse after a failed logon to reset lockout trigger */
+  lockoutObservationWindow?: number;
+  /** number of attempts before account to be locked */
+  lockoutThreshold?: number | null;
+  /** maximum number of days that account's password is valid before expiration */
+  maxPasswordAge?: number | null;
+  /** Maximum message size that You can receive in MB */
+  maxReceiveSize?: number;
+  /** Maximum message size that You can send in MB */
+  maxSendSize?: number;
+  /** minimum number of days before able to change account's password */
+  minPasswordAge?: number | null;
+  /** minimum number of characters password must contain */
+  minPasswordLength?: number | null;
+  /** Type of your offer */
+  offer?: EmailProServiceOfferEnum;
+  /** Spam and Antivirus configuration */
+  spamAndVirusConfiguration?: EmailProSpamAndVirusConfiguration;
+  /** State of your service */
+  state?: EmailProServiceStateEnum;
+  /** Task pending id */
+  taskPendingId?: number;
+  /** URL for web interface */
+  webUrl?: string | null;
+}
+export const EmailProServiceNativeWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    complexityEnabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    domain: S.optional(S.String),
+    hostname: S.optional(S.NullOr(S.String)),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    lastUpdateDate: S.optional(S.NullOr(S.String)),
+    lockoutDuration: S.optional(S.Number),
+    lockoutObservationWindow: S.optional(S.Number),
+    lockoutThreshold: S.optional(S.NullOr(S.Number)),
+    maxPasswordAge: S.optional(S.NullOr(S.Number)),
+    maxReceiveSize: S.optional(S.Number),
+    maxSendSize: S.optional(S.Number),
+    minPasswordAge: S.optional(S.NullOr(S.Number)),
+    minPasswordLength: S.optional(S.NullOr(S.Number)),
+    offer: S.optional(EmailProServiceOfferEnum),
+    spamAndVirusConfiguration: S.optional(EmailProSpamAndVirusConfiguration),
+    state: S.optional(EmailProServiceStateEnum),
+    taskPendingId: S.optional(S.Number),
+    webUrl: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "EmailProServiceNativeWithIAM",
+}) as any as S.Schema<EmailProServiceNativeWithIAM>;
+
+export interface GetEmailProAccountRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const GetEmailProAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProAccountRequest",
+}) as any as S.Schema<GetEmailProAccountRequest>;
+
+/** Mailing filter options availlable */
+export type EmailProMailingFilterEnum = "vaderetro";
+export const EmailProMailingFilterEnum = /*@__PURE__*/ S.String;
+
+/** Enable or disable anti-virus and anti-spam */
+export type EmailProAccountNativeMailingFilterList =
+  Array<EmailProMailingFilterEnum>;
+export const EmailProAccountNativeMailingFilterList = /*@__PURE__*/ S.Array(
+  EmailProMailingFilterEnum,
+) as any as S.Schema<EmailProAccountNativeMailingFilterList>;
+
+/** Renew period */
+export type EmailProRenewPeriodEnum = "monthly" | "yearly";
+export const EmailProRenewPeriodEnum = /*@__PURE__*/ S.String;
+
+/** Current object state */
+export type EmailProObjectStateEnum =
+  | "creating"
+  | "deleting"
+  | "ok"
+  | "reopening"
+  | "suspended"
+  | "suspending"
+  | "unknown";
+export const EmailProObjectStateEnum = /*@__PURE__*/ S.String;
+
+/** Mailbox */
+export interface EmailProAccountNative {
+  /** SAM account name */
+  SAMAccountName?: string | null;
+  /** Indicates if the account is configured */
+  configured?: boolean;
+  /** Creation date */
+  creationDate?: string | null;
+  /** Mailbox usage */
+  currentUsage?: number | null;
+  /** delete at expiration */
+  deleteAtExpiration?: boolean | null;
+  /** Account display name */
+  displayName?: string | null;
+  /** Email domain */
+  domain?: string;
+  /** expiration date */
+  expirationDate?: string | null;
+  /** expiration date */
+  expirationOutlookDate?: string | null;
+  /** Account first name */
+  firstName?: string | null;
+  /** Hide account in Global Address List */
+  hiddenFromGAL?: boolean;
+  /** Account id */
+  id?: number;
+  /** Account initials */
+  initial?: string | null;
+  /** Last logoff */
+  lastLogoffDate?: string | null;
+  /** Last logon */
+  lastLogonDate?: string | null;
+  /** Account last name */
+  lastName?: string | null;
+  /** Last update */
+  lastUpdateDate?: string | null;
+  /** Account login */
+  login?: string;
+  /** Enable or disable anti-virus and anti-spam */
+  mailingFilter?: EmailProAccountNativeMailingFilterList | null;
+  /** Time of account's password last update */
+  passwordLastUpdate?: string | Redacted.Redacted<string> | null;
+  /** Default email for this mailbox */
+  primaryEmailAddress?: string;
+  /** Account maximum size */
+  quota?: number;
+  /** change the renew period */
+  renewPeriod?: EmailProRenewPeriodEnum | null;
+  /** Spam and Antivirus configuration */
+  spamAndVirusConfiguration?: EmailProSpamAndVirusConfiguration;
+  /** Account was sending spam */
+  spamDetected?: boolean;
+  /** Ticket number of spam detection */
+  spamTicketNumber?: number | null;
+  /** Account state */
+  state?: EmailProObjectStateEnum;
+  /** Pending tasks for this account */
+  taskPendingId?: number | null;
+}
+export const EmailProAccountNative = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    SAMAccountName: S.optional(S.NullOr(S.String)),
+    configured: S.optional(S.Boolean),
+    creationDate: S.optional(S.NullOr(S.String)),
+    currentUsage: S.optional(S.NullOr(S.Number)),
+    deleteAtExpiration: S.optional(S.NullOr(S.Boolean)),
+    displayName: S.optional(S.NullOr(S.String)),
+    domain: S.optional(S.String),
+    expirationDate: S.optional(S.NullOr(S.String)),
+    expirationOutlookDate: S.optional(S.NullOr(S.String)),
+    firstName: S.optional(S.NullOr(S.String)),
+    hiddenFromGAL: S.optional(S.Boolean),
+    id: S.optional(S.Number),
+    initial: S.optional(S.NullOr(S.String)),
+    lastLogoffDate: S.optional(S.NullOr(S.String)),
+    lastLogonDate: S.optional(S.NullOr(S.String)),
+    lastName: S.optional(S.NullOr(S.String)),
+    lastUpdateDate: S.optional(S.NullOr(S.String)),
+    login: S.optional(S.String),
+    mailingFilter: S.optional(S.NullOr(EmailProAccountNativeMailingFilterList)),
+    passwordLastUpdate: S.optional(
+      S.NullOr(S.String).pipe(T.SensitiveValue({})),
+    ),
+    primaryEmailAddress: S.optional(S.String),
+    quota: S.optional(S.Number),
+    renewPeriod: S.optional(S.NullOr(EmailProRenewPeriodEnum)),
+    spamAndVirusConfiguration: S.optional(EmailProSpamAndVirusConfiguration),
+    spamDetected: S.optional(S.Boolean),
+    spamTicketNumber: S.optional(S.NullOr(S.Number)),
+    state: S.optional(EmailProObjectStateEnum),
+    taskPendingId: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "EmailProAccountNative",
+}) as any as S.Schema<EmailProAccountNative>;
+
+export interface GetEmailProAccountAliasRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+  /** Alias */
+  alias: string;
+}
+export const GetEmailProAccountAliasRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    alias: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/alias/{alias}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProAccountAliasRequest",
+}) as any as S.Schema<GetEmailProAccountAliasRequest>;
+
+/** Aliases on this mailbox */
+export interface EmailProAccountAlias {
+  /** Alias */
+  alias?: string;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailProAccountAlias = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    alias: S.optional(S.String),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailProAccountAlias",
+}) as any as S.Schema<EmailProAccountAlias>;
+
+export interface GetEmailProAccountDiagnosticsRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const GetEmailProAccountDiagnosticsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/pro/{service}/account/{email}/diagnostics",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetEmailProAccountDiagnosticsRequest",
+}) as any as S.Schema<GetEmailProAccountDiagnosticsRequest>;
+
+/** Account Diagnosis */
+export interface EmailProAccountDiagnosis {
+  /** Determines if ingoing message has been received */
+  canReceiveEmail?: boolean;
+  /** Determines if outgoing message has been delivered */
+  canSendEmail?: boolean;
+  /** Determines if possible to authenticate with credentials */
+  connectiveWebmail?: boolean;
+  /** Determines if account is locked */
+  isLocked?: boolean;
+  /** Determines if MX record for account's domain is properly set */
+  isMxValid?: boolean;
+  /** Determines if account is flagged as spammer */
+  isSpammer?: boolean;
+  /** Determines if SRV (autodiscovery) record for account's domain is properly set */
+  isSrvValid?: boolean;
+  /** Determines if account is suspended */
+  isSuspended?: boolean;
+  /** Last performed diagnostics date */
+  lastCheck?: string;
+}
+export const EmailProAccountDiagnosis = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canReceiveEmail: S.optional(S.Boolean),
+    canSendEmail: S.optional(S.Boolean),
+    connectiveWebmail: S.optional(S.Boolean),
+    isLocked: S.optional(S.Boolean),
+    isMxValid: S.optional(S.Boolean),
+    isSpammer: S.optional(S.Boolean),
+    isSrvValid: S.optional(S.Boolean),
+    isSuspended: S.optional(S.Boolean),
+    lastCheck: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "EmailProAccountDiagnosis",
+}) as any as S.Schema<EmailProAccountDiagnosis>;
+
+export interface GetEmailProAccountFullAccessRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+  /** Allowed account ID */
+  allowedAccountId: number;
+}
+export const GetEmailProAccountFullAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    allowedAccountId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/fullAccess/{allowedAccountId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProAccountFullAccessRequest",
+}) as any as S.Schema<GetEmailProAccountFullAccessRequest>;
+
+/** Users having full access on this mailbox */
+export interface EmailProAccountFullAccess {
+  /** Account id to give full access */
+  allowedAccountId?: number;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailProAccountFullAccess = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedAccountId: S.optional(S.Number),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailProAccountFullAccess",
+}) as any as S.Schema<EmailProAccountFullAccess>;
+
+export interface GetEmailProAccountSendAsRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+  /** Allowed account ID */
+  allowedAccountId: number;
+}
+export const GetEmailProAccountSendAsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    allowedAccountId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/sendAs/{allowedAccountId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProAccountSendAsRequest",
+}) as any as S.Schema<GetEmailProAccountSendAsRequest>;
+
+/** Users authorized to send mails from this mailbox */
+export interface EmailProAccountSendAs {
+  /** Account id to give send as */
+  allowedAccountId?: number;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailProAccountSendAs = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedAccountId: S.optional(S.Number),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailProAccountSendAs",
+}) as any as S.Schema<EmailProAccountSendAs>;
+
+export interface GetEmailProAccountSendOnBehalfToRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+  /** Allowed account ID */
+  allowedAccountId: number;
+}
+export const GetEmailProAccountSendOnBehalfToRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      allowedAccountId: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/pro/{service}/account/{email}/sendOnBehalfTo/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetEmailProAccountSendOnBehalfToRequest",
+}) as any as S.Schema<GetEmailProAccountSendOnBehalfToRequest>;
+
+/** Get users authorized to Send On Behalf To mails from this mailbox */
+export interface EmailProAccountSendOnBehalfTo {
+  /** Account id to give send on behalf to */
+  allowedAccountId?: number;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailProAccountSendOnBehalfTo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedAccountId: S.optional(S.Number),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailProAccountSendOnBehalfTo",
+}) as any as S.Schema<EmailProAccountSendOnBehalfTo>;
+
+export interface GetEmailProAccountTaskRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+  /** Id */
+  id: number;
+}
+export const GetEmailProAccountTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/tasks/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProAccountTaskRequest",
+}) as any as S.Schema<GetEmailProAccountTaskRequest>;
+
+export interface GetEmailProBillingMigratedRequest {
+  /** Service */
+  service: string;
+}
+export const GetEmailProBillingMigratedRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/billingMigrated",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProBillingMigratedRequest",
+}) as any as S.Schema<GetEmailProBillingMigratedRequest>;
+
+export type GetEmailProBillingMigratedResponse = boolean;
+export const GetEmailProBillingMigratedResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Boolean.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetEmailProBillingMigratedResponse",
+}) as any as S.Schema<GetEmailProBillingMigratedResponse>;
+
+export interface GetEmailProBillingPlanRequest {
+  /** Service */
+  service: string;
+}
+export const GetEmailProBillingPlanRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/billingPlan",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProBillingPlanRequest",
+}) as any as S.Schema<GetEmailProBillingPlanRequest>;
+
+export type GetEmailProBillingPlanResponse = string;
+export const GetEmailProBillingPlanResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetEmailProBillingPlanResponse",
+}) as any as S.Schema<GetEmailProBillingPlanResponse>;
+
+export interface GetEmailProDomainRequest {
+  /** Service */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const GetEmailProDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/domain/{domainName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProDomainRequest",
+}) as any as S.Schema<GetEmailProDomainRequest>;
+
+/** DKIM status */
+export type EmailProDomainDkimDiagnosticsStateEnum =
+  | "active"
+  | "disabled"
+  | "error"
+  | "inProgress"
+  | "toConfigure";
+export const EmailProDomainDkimDiagnosticsStateEnum = /*@__PURE__*/ S.String;
+
+/** Dkim selectors and DNS configuration state */
+export interface EmailProDomainDkimDiagnostics {
+  /** Error code related to misconfiguration of DKIM, if exists */
+  errorCode?: number | null;
+  /** DKIM misconfiguration description, if exists */
+  message?: string | null;
+  /** State of DKIM selectors */
+  state?: EmailProDomainDkimDiagnosticsStateEnum | null;
+}
+export const EmailProDomainDkimDiagnostics = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    errorCode: S.optional(S.NullOr(S.Number)),
+    message: S.optional(S.NullOr(S.String)),
+    state: S.optional(S.NullOr(EmailProDomainDkimDiagnosticsStateEnum)),
+  }),
+).annotate({
+  identifier: "EmailProDomainDkimDiagnostics",
+}) as any as S.Schema<EmailProDomainDkimDiagnostics>;
+
+/** List of aliases for this domain */
+export type EmailProDomainNativeDomainAliasesList = Array<string>;
+export const EmailProDomainNativeDomainAliasesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailProDomainNativeDomainAliasesList>;
+
+/** Expected MX record(s) on this domain */
+export type EmailProDomainNativeExpectedMXList = Array<string>;
+export const EmailProDomainNativeExpectedMXList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailProDomainNativeExpectedMXList>;
+
+/** Domain MX record configured in DNS */
+export type EmailProDomainNativeMxRecordList = Array<string>;
+export const EmailProDomainNativeMxRecordList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailProDomainNativeMxRecordList>;
+
+/** Domain's SPF record configured in the DNS */
+export type EmailProDomainNativeSpfRecordList = Array<string>;
+export const EmailProDomainNativeSpfRecordList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailProDomainNativeSpfRecordList>;
+
+/** Domain SRV record configured in DNS */
+export type EmailProDomainNativeSrvRecordList = Array<string>;
+export const EmailProDomainNativeSrvRecordList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailProDomainNativeSrvRecordList>;
+
+/** Domain */
+export interface EmailProDomainNative {
+  /** Cname that will be checked to prove the domain ownership */
+  cnameToCheck?: string | null;
+  /** Dkim selectors and DNS configuration state */
+  dkimDiagnostics?: EmailProDomainDkimDiagnostics | null;
+  /** List of aliases for this domain */
+  domainAliases?: EmailProDomainNativeDomainAliasesList;
+  /** Domain validation status */
+  domainValidated?: boolean;
+  /** Expected SRV record on this domain */
+  expectedAutodiscoverSRV?: string;
+  /** Expected MX record(s) on this domain */
+  expectedMX?: EmailProDomainNativeExpectedMXList;
+  /** Expected SPF record on this domain */
+  expectedSPF?: string;
+  /** Indicate if this domain is an alias for another domain */
+  isAliasDomain?: boolean;
+  /** If true your DNS MX configuration is valid */
+  mxIsValid?: boolean;
+  /** Domain MX record configured in DNS */
+  mxRecord?: EmailProDomainNativeMxRecordList | null;
+  /** If specified, emails to not existing address will be redirected to that domain */
+  mxRelay?: string | null;
+  /** Domain name */
+  name?: string;
+  /** SPF record validation passed */
+  spfIsValid?: boolean;
+  /** Domain's SPF record configured in the DNS */
+  spfRecord?: EmailProDomainNativeSpfRecordList | null;
+  /** If true your DNS SRV record is valid */
+  srvIsValid?: boolean;
+  /** Domain SRV record configured in DNS */
+  srvRecord?: EmailProDomainNativeSrvRecordList | null;
+  /** Domain state */
+  state?: EmailProObjectStateEnum;
+  /** Pending tasks id */
+  taskPendingId?: number;
+  /** Domain type */
+  type?: EmailProDomainTypeEnum;
+}
+export const EmailProDomainNative = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cnameToCheck: S.optional(S.NullOr(S.String)),
+    dkimDiagnostics: S.optional(S.NullOr(EmailProDomainDkimDiagnostics)),
+    domainAliases: S.optional(EmailProDomainNativeDomainAliasesList),
+    domainValidated: S.optional(S.Boolean),
+    expectedAutodiscoverSRV: S.optional(S.String),
+    expectedMX: S.optional(EmailProDomainNativeExpectedMXList),
+    expectedSPF: S.optional(S.String),
+    isAliasDomain: S.optional(S.Boolean),
+    mxIsValid: S.optional(S.Boolean),
+    mxRecord: S.optional(S.NullOr(EmailProDomainNativeMxRecordList)),
+    mxRelay: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+    spfIsValid: S.optional(S.Boolean),
+    spfRecord: S.optional(S.NullOr(EmailProDomainNativeSpfRecordList)),
+    srvIsValid: S.optional(S.Boolean),
+    srvRecord: S.optional(S.NullOr(EmailProDomainNativeSrvRecordList)),
+    state: S.optional(EmailProObjectStateEnum),
+    taskPendingId: S.optional(S.Number),
+    type: S.optional(EmailProDomainTypeEnum),
+  }),
+).annotate({
+  identifier: "EmailProDomainNative",
+}) as any as S.Schema<EmailProDomainNative>;
+
+export interface GetEmailProDomainDisclaimerRequest {
+  /** Service */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const GetEmailProDomainDisclaimerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/domain/{domainName}/disclaimer",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProDomainDisclaimerRequest",
+}) as any as S.Schema<GetEmailProDomainDisclaimerRequest>;
+
+/** disclaimer */
+export interface EmailProDisclaimerNative {
+  /** Signature, added at the bottom of your organization emails */
+  content?: string;
+  /** Creation date */
+  creationDate?: string;
+  /** Disclaimer name */
+  name?: string;
+  /** Activate the disclaimer only for external emails */
+  outsideOnly?: boolean;
+  /** task pending id */
+  taskPendingId?: number;
+}
+export const EmailProDisclaimerNative = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    content: S.optional(S.String),
+    creationDate: S.optional(S.String),
+    name: S.optional(S.String),
+    outsideOnly: S.optional(S.Boolean),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailProDisclaimerNative",
+}) as any as S.Schema<EmailProDisclaimerNative>;
+
+export interface GetEmailProDomainDkimRequest {
+  /** Service */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** Selector name */
+  selectorName: string;
+}
+export const GetEmailProDomainDkimRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    selectorName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/domain/{domainName}/dkim/{selectorName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProDomainDkimRequest",
+}) as any as S.Schema<GetEmailProDomainDkimRequest>;
+
+/** Record type of the customer record */
+export type EmailProDkimRecordTypeEnum = "CNAME";
+export const EmailProDkimRecordTypeEnum = /*@__PURE__*/ S.String;
+
+/** DKIM status */
+export type EmailProDkimStatusEnum =
+  | "deleting"
+  | "disabling"
+  | "enabling"
+  | "inProduction"
+  | "ready"
+  | "todo"
+  | "waitingRecord";
+export const EmailProDkimStatusEnum = /*@__PURE__*/ S.String;
+
+/** DKIM for a domain */
+export interface EmailProDkim {
+  /** DNS CNAME validation passed */
+  cnameIsValid?: boolean;
+  /** Customer DNS record */
+  customerRecord?: string;
+  /** Header used for DKIM signature */
+  header?: string;
+  /** Last update date */
+  lastUpdate?: string | null;
+  /** Record type of the customer record */
+  recordType?: EmailProDkimRecordTypeEnum;
+  /** Selector name */
+  selectorName?: string;
+  /** DKIM status */
+  status?: EmailProDkimStatusEnum;
+  /** Target of the customer record */
+  targetRecord?: string | null;
+  /** Pending task for this DKIM */
+  taskPendingId?: number | null;
+}
+export const EmailProDkim = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cnameIsValid: S.optional(S.Boolean),
+    customerRecord: S.optional(S.String),
+    header: S.optional(S.String),
+    lastUpdate: S.optional(S.NullOr(S.String)),
+    recordType: S.optional(EmailProDkimRecordTypeEnum),
+    selectorName: S.optional(S.String),
+    status: S.optional(EmailProDkimStatusEnum),
+    targetRecord: S.optional(S.NullOr(S.String)),
+    taskPendingId: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({ identifier: "EmailProDkim" }) as any as S.Schema<EmailProDkim>;
+
+export interface GetEmailProExternalContactRequest {
+  /** Service */
+  service: string;
+  /** External email address */
+  externalEmailAddress: string;
+}
+export const GetEmailProExternalContactRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    externalEmailAddress: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/externalContact/{externalEmailAddress}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProExternalContactRequest",
+}) as any as S.Schema<GetEmailProExternalContactRequest>;
+
+/** External contact for this pro service */
+export interface EmailProExternalContactNative {
+  /** Creation date */
+  creationDate?: string;
+  /** Contact display name */
+  displayName?: string;
+  /** Contact email */
+  externalEmailAddress?: string;
+  /** Contact first name */
+  firstName?: string | null;
+  /** Hide the contact in Global Address List */
+  hiddenFromGAL?: boolean;
+  /** Contact id */
+  id?: number;
+  /** Contact initals */
+  initials?: string | null;
+  /** Contact last name */
+  lastName?: string | null;
+  /** Contact state */
+  state?: EmailProObjectStateEnum;
+  /** Task pending id */
+  taskPendingId?: number;
+}
+export const EmailProExternalContactNative = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    displayName: S.optional(S.String),
+    externalEmailAddress: S.optional(S.String),
+    firstName: S.optional(S.NullOr(S.String)),
+    hiddenFromGAL: S.optional(S.Boolean),
+    id: S.optional(S.Number),
+    initials: S.optional(S.NullOr(S.String)),
+    lastName: S.optional(S.NullOr(S.String)),
+    state: S.optional(EmailProObjectStateEnum),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailProExternalContactNative",
+}) as any as S.Schema<EmailProExternalContactNative>;
+
+export interface GetEmailProServerRequest {
+  /** Service */
+  service: string;
+}
+export const GetEmailProServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/pro/{service}/server", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetEmailProServerRequest",
+}) as any as S.Schema<GetEmailProServerRequest>;
+
+/** Server State */
+export type EmailProServerStateEnum =
+  | "configurationPending"
+  | "notConfigured"
+  | "ok";
+export const EmailProServerStateEnum = /*@__PURE__*/ S.String;
+
+/** Server */
+export interface EmailProServer {
+  /** Current disk usage in MB */
+  currentDiskUsage?: number | null;
+  /** Total disk size in MB */
+  diskSize?: number | null;
+  /** ipV4 */
+  ip?: string;
+  /** ipV6 */
+  ipV6?: string | null;
+  /** If true your dns A record is valid */
+  isAValid?: boolean;
+  /** If true your dns AAAA record is valid */
+  isAaaaValid?: boolean;
+  /** If true your dns ptrV6 record is valid */
+  isPtrV6Valid?: boolean;
+  /** If true your dns ptr record is valid */
+  isPtrValid?: boolean;
+  /** Server state */
+  state?: EmailProServerStateEnum;
+  /** Task pending id */
+  taskPendingId?: number;
+  /** Server version */
+  version?: string | null;
+}
+export const EmailProServer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    currentDiskUsage: S.optional(S.NullOr(S.Number)),
+    diskSize: S.optional(S.NullOr(S.Number)),
+    ip: S.optional(S.String),
+    ipV6: S.optional(S.NullOr(S.String)),
+    isAValid: S.optional(S.Boolean),
+    isAaaaValid: S.optional(S.Boolean),
+    isPtrV6Valid: S.optional(S.Boolean),
+    isPtrValid: S.optional(S.Boolean),
+    state: S.optional(EmailProServerStateEnum),
+    taskPendingId: S.optional(S.Number),
+    version: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "EmailProServer" }) as any as S.Schema<EmailProServer>;
+
+export interface GetEmailProServiceInfosRequest {
+  /** The internal name of your pro organization */
+  service: string;
+}
+export const GetEmailProServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailProServiceInfosRequest",
+}) as any as S.Schema<GetEmailProServiceInfosRequest>;
+
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export const ServicesServicePossibleRenewPeriodList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as 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 const ServiceRenewType = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    automatic: S.optional(S.Boolean),
+    deleteAtExpiration: S.optional(S.Boolean),
+    forced: S.optional(S.Boolean),
+    manualPayment: S.optional(S.NullOr(S.Boolean)),
+    period: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "ServiceRenewType",
+}) as any as S.Schema<ServiceRenewType>;
+
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum =
+  | "automaticForcedProduct"
+  | "automaticV2012"
+  | "automaticV2014"
+  | "automaticV2016"
+  | "automaticV2024"
+  | "manual"
+  | "oneShot"
+  | "option";
+export const ServiceRenewalTypeEnum = /*@__PURE__*/ S.String;
+
+export type ServiceStateEnum =
+  | "autorenewInProgress"
+  | "expired"
+  | "inCreation"
+  | "ok"
+  | "pendingDebt"
+  | "unPaid";
+export const ServiceStateEnum = /*@__PURE__*/ S.String;
+
+/** 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 const ServicesService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canDeleteAtExpiration: S.optional(S.Boolean),
+    contactAdmin: S.optional(S.String),
+    contactBilling: S.optional(S.String),
+    contactTech: S.optional(S.String),
+    creation: S.optional(S.String),
+    domain: S.optional(S.String),
+    engagedUpTo: S.optional(S.NullOr(S.String)),
+    expiration: S.optional(S.String),
+    possibleRenewPeriod: S.optional(
+      S.NullOr(ServicesServicePossibleRenewPeriodList),
+    ),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+    renewalType: S.optional(ServiceRenewalTypeEnum),
+    serviceId: S.optional(S.Number),
+    status: S.optional(ServiceStateEnum),
+  }),
+).annotate({
+  identifier: "ServicesService",
+}) as any as S.Schema<ServicesService>;
+
+export interface GetEmailProTaskRequest {
+  /** Service */
+  service: string;
+  /** Id */
+  id: number;
+}
+export const GetEmailProTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/pro/{service}/task/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetEmailProTaskRequest",
+}) as any as S.Schema<GetEmailProTaskRequest>;
+
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {}
+export const IamResourceTagFilterInput = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IamResourceTagFilterInput",
+}) as any as S.Schema<IamResourceTagFilterInput>;
+
+export type ListEmailProRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListEmailProRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListEmailProRequestIamTagsValueList>;
+
+export type ListEmailProRequestIamTagsMap = {
+  [key: string]: ListEmailProRequestIamTagsValueList | undefined;
+};
+export const ListEmailProRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListEmailProRequestIamTagsValueList,
+) as any as S.Schema<ListEmailProRequestIamTagsMap>;
+
+export interface ListEmailProRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListEmailProRequestIamTagsMap;
+}
+export const ListEmailProRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListEmailProRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/email/pro", code: 200 })),
+).annotate({
+  identifier: "ListEmailProRequest",
+}) as any as S.Schema<ListEmailProRequest>;
+
+export type ListEmailProResponseBodyList = Array<string>;
+export const ListEmailProResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailProResponseBodyList>;
+
+export type ListEmailProResponse = ListEmailProResponseBodyList;
+export const ListEmailProResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProResponse",
+}) as any as S.Schema<ListEmailProResponse>;
+
+export interface ListEmailProAccountRequest {
+  /** Service */
+  service: string;
+  /** Filter the value of id property (like) */
+  id?: number;
+  /** Filter the value of primaryEmailAddress property (like) */
+  primaryEmailAddress?: string;
+}
+export const ListEmailProAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    id: S.optional(S.Number.pipe(T.Query())),
+    primaryEmailAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/pro/{service}/account", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListEmailProAccountRequest",
+}) as any as S.Schema<ListEmailProAccountRequest>;
+
+export type ListEmailProAccountResponseBodyList = Array<string>;
+export const ListEmailProAccountResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailProAccountResponseBodyList>;
+
+export type ListEmailProAccountResponse = ListEmailProAccountResponseBodyList;
+export const ListEmailProAccountResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProAccountResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProAccountResponse",
+}) as any as S.Schema<ListEmailProAccountResponse>;
+
+export interface ListEmailProAccountAliasRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const ListEmailProAccountAliasRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/alias",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailProAccountAliasRequest",
+}) as any as S.Schema<ListEmailProAccountAliasRequest>;
+
+export type ListEmailProAccountAliasResponseBodyList = Array<string>;
+export const ListEmailProAccountAliasResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailProAccountAliasResponseBodyList>;
+
+export type ListEmailProAccountAliasResponse =
+  ListEmailProAccountAliasResponseBodyList;
+export const ListEmailProAccountAliasResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProAccountAliasResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProAccountAliasResponse",
+}) as any as S.Schema<ListEmailProAccountAliasResponse>;
+
+export interface ListEmailProAccountFullAccessRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const ListEmailProAccountFullAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/pro/{service}/account/{email}/fullAccess",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListEmailProAccountFullAccessRequest",
+}) as any as S.Schema<ListEmailProAccountFullAccessRequest>;
+
+export type ListEmailProAccountFullAccessResponseBodyList = Array<number>;
+export const ListEmailProAccountFullAccessResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListEmailProAccountFullAccessResponseBodyList>;
+
+export type ListEmailProAccountFullAccessResponse =
+  ListEmailProAccountFullAccessResponseBodyList;
+export const ListEmailProAccountFullAccessResponse = /*@__PURE__*/ S.suspend(
+  () => ListEmailProAccountFullAccessResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProAccountFullAccessResponse",
+}) as any as S.Schema<ListEmailProAccountFullAccessResponse>;
+
+export interface ListEmailProAccountSendAsRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const ListEmailProAccountSendAsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/sendAs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailProAccountSendAsRequest",
+}) as any as S.Schema<ListEmailProAccountSendAsRequest>;
+
+export type ListEmailProAccountSendAsResponseBodyList = Array<number>;
+export const ListEmailProAccountSendAsResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListEmailProAccountSendAsResponseBodyList>;
+
+export type ListEmailProAccountSendAsResponse =
+  ListEmailProAccountSendAsResponseBodyList;
+export const ListEmailProAccountSendAsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProAccountSendAsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProAccountSendAsResponse",
+}) as any as S.Schema<ListEmailProAccountSendAsResponse>;
+
+export interface ListEmailProAccountSendOnBehalfToRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const ListEmailProAccountSendOnBehalfToRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/pro/{service}/account/{email}/sendOnBehalfTo",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListEmailProAccountSendOnBehalfToRequest",
+}) as any as S.Schema<ListEmailProAccountSendOnBehalfToRequest>;
+
+export type ListEmailProAccountSendOnBehalfToResponseBodyList = Array<number>;
+export const ListEmailProAccountSendOnBehalfToResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListEmailProAccountSendOnBehalfToResponseBodyList>;
+
+export type ListEmailProAccountSendOnBehalfToResponse =
+  ListEmailProAccountSendOnBehalfToResponseBodyList;
+export const ListEmailProAccountSendOnBehalfToResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListEmailProAccountSendOnBehalfToResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "ListEmailProAccountSendOnBehalfToResponse",
+  }) as any as S.Schema<ListEmailProAccountSendOnBehalfToResponse>;
+
+export interface ListEmailProAccountTasksRequest {
+  /** Service */
+  service: string;
+  /** Email */
+  email: string;
+}
+export const ListEmailProAccountTasksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/account/{email}/tasks",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailProAccountTasksRequest",
+}) as any as S.Schema<ListEmailProAccountTasksRequest>;
+
+export type ListEmailProAccountTasksResponseBodyList = Array<number>;
+export const ListEmailProAccountTasksResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListEmailProAccountTasksResponseBodyList>;
+
+export type ListEmailProAccountTasksResponse =
+  ListEmailProAccountTasksResponseBodyList;
+export const ListEmailProAccountTasksResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProAccountTasksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProAccountTasksResponse",
+}) as any as S.Schema<ListEmailProAccountTasksResponse>;
+
+export interface ListEmailProDomainRequest {
+  /** Service */
+  service: string;
+  /** Filter the value of state property (=) */
+  state?: EmailProObjectStateEnum | (string & {});
+}
+export const ListEmailProDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    state: S.optional(EmailProObjectStateEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/pro/{service}/domain", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListEmailProDomainRequest",
+}) as any as S.Schema<ListEmailProDomainRequest>;
+
+export type ListEmailProDomainResponseBodyList = Array<string>;
+export const ListEmailProDomainResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailProDomainResponseBodyList>;
+
+export type ListEmailProDomainResponse = ListEmailProDomainResponseBodyList;
+export const ListEmailProDomainResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProDomainResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProDomainResponse",
+}) as any as S.Schema<ListEmailProDomainResponse>;
+
+export interface ListEmailProDomainDisclaimerAttributeRequest {
+  /** Service */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const ListEmailProDomainDisclaimerAttributeRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/pro/{service}/domain/{domainName}/disclaimerAttribute",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListEmailProDomainDisclaimerAttributeRequest",
+  }) as any as S.Schema<ListEmailProDomainDisclaimerAttributeRequest>;
+
+/** Disclaimer attributes list */
+export type EmailProDisclaimerAttributeEnum =
+  | "City"
+  | "Company"
+  | "Country"
+  | "Department"
+  | "DisplayName"
+  | "Email"
+  | "FaxNumber"
+  | "FirstName"
+  | "HomePhoneNumber"
+  | "Initials"
+  | "LastName"
+  | "Manager"
+  | "MobileNumber"
+  | "Notes"
+  | "Office"
+  | "OtherFaxNumber"
+  | "OtherHomePhoneNumber"
+  | "OtherPhoneNumber"
+  | "PagerNumber"
+  | "PhoneNumber"
+  | "State"
+  | "Street"
+  | "Title"
+  | "UserLogonName"
+  | "ZipCode";
+export const EmailProDisclaimerAttributeEnum = /*@__PURE__*/ S.String;
+
+export type ListEmailProDomainDisclaimerAttributeResponseBodyList =
+  Array<EmailProDisclaimerAttributeEnum>;
+export const ListEmailProDomainDisclaimerAttributeResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    EmailProDisclaimerAttributeEnum,
+  ) as any as S.Schema<ListEmailProDomainDisclaimerAttributeResponseBodyList>;
+
+export type ListEmailProDomainDisclaimerAttributeResponse =
+  ListEmailProDomainDisclaimerAttributeResponseBodyList;
+export const ListEmailProDomainDisclaimerAttributeResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListEmailProDomainDisclaimerAttributeResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListEmailProDomainDisclaimerAttributeResponse",
+  }) as any as S.Schema<ListEmailProDomainDisclaimerAttributeResponse>;
+
+export interface ListEmailProDomainDkimRequest {
+  /** Service */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const ListEmailProDomainDkimRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/domain/{domainName}/dkim",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailProDomainDkimRequest",
+}) as any as S.Schema<ListEmailProDomainDkimRequest>;
+
+export type ListEmailProDomainDkimResponseBodyList = Array<string>;
+export const ListEmailProDomainDkimResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailProDomainDkimResponseBodyList>;
+
+export type ListEmailProDomainDkimResponse =
+  ListEmailProDomainDkimResponseBodyList;
+export const ListEmailProDomainDkimResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProDomainDkimResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProDomainDkimResponse",
+}) as any as S.Schema<ListEmailProDomainDkimResponse>;
+
+export interface ListEmailProDomainDkimSelectorRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const ListEmailProDomainDkimSelectorRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/pro/{service}/domain/{domainName}/dkimSelector",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListEmailProDomainDkimSelectorRequest",
+}) as any as S.Schema<ListEmailProDomainDkimSelectorRequest>;
+
+export type ListEmailProDomainDkimSelectorResponseBodyList = Array<string>;
+export const ListEmailProDomainDkimSelectorResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListEmailProDomainDkimSelectorResponseBodyList>;
+
+export type ListEmailProDomainDkimSelectorResponse =
+  ListEmailProDomainDkimSelectorResponseBodyList;
+export const ListEmailProDomainDkimSelectorResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListEmailProDomainDkimSelectorResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProDomainDkimSelectorResponse",
+}) as any as S.Schema<ListEmailProDomainDkimSelectorResponse>;
+
+export interface ListEmailProExternalContactRequest {
+  /** Service */
+  service: string;
+  /** Filter the value of displayName property (like) */
+  displayName?: string;
+  /** Filter the value of externalEmailAddress property (like) */
+  externalEmailAddress?: string;
+  /** Filter the value of firstName property (like) */
+  firstName?: string;
+  /** Filter the value of id property (like) */
+  id?: number;
+  /** Filter the value of lastName property (like) */
+  lastName?: string;
+}
+export const ListEmailProExternalContactRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    displayName: S.optional(S.String.pipe(T.Query())),
+    externalEmailAddress: S.optional(S.String.pipe(T.Query())),
+    firstName: S.optional(S.String.pipe(T.Query())),
+    id: S.optional(S.Number.pipe(T.Query())),
+    lastName: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/pro/{service}/externalContact",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailProExternalContactRequest",
+}) as any as S.Schema<ListEmailProExternalContactRequest>;
+
+export type ListEmailProExternalContactResponseBodyList = Array<string>;
+export const ListEmailProExternalContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListEmailProExternalContactResponseBodyList>;
+
+export type ListEmailProExternalContactResponse =
+  ListEmailProExternalContactResponseBodyList;
+export const ListEmailProExternalContactResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProExternalContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProExternalContactResponse",
+}) as any as S.Schema<ListEmailProExternalContactResponse>;
+
+export interface ListEmailProTaskRequest {
+  /** Service */
+  service: string;
+}
+export const ListEmailProTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/pro/{service}/task", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListEmailProTaskRequest",
+}) as any as S.Schema<ListEmailProTaskRequest>;
+
+export type ListEmailProTaskResponseBodyList = Array<number>;
+export const ListEmailProTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListEmailProTaskResponseBodyList>;
+
+export type ListEmailProTaskResponse = ListEmailProTaskResponseBodyList;
+export const ListEmailProTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailProTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailProTaskResponse",
+}) as any as S.Schema<ListEmailProTaskResponse>;
+
+/** Spam and Antyvirus configuration */
+export type EmailProSpamAndVirusConfigurationInput = IamResourceTagFilterInput;
+export const EmailProSpamAndVirusConfigurationInput = IamResourceTagFilterInput;
+
+export interface PutEmailProRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** enable policy for strong and secure passwords */
+  complexityEnabled?: boolean;
+  /** service displayName */
+  displayName?: string | null;
+  /** number of minutes account will remain locked if it occurs */
+  lockoutDuration?: number;
+  /** number of minutes that must elapse after a failed logon to reset lockout trigger */
+  lockoutObservationWindow?: number;
+  /** number of attempts before account to be locked */
+  lockoutThreshold?: number | null;
+  /** maximum number of days that account's password is valid before expiration */
+  maxPasswordAge?: number | null;
+  /** Maximum message size that You can receive in MB */
+  maxReceiveSize?: number;
+  /** Maximum message size that You can send in MB */
+  maxSendSize?: number;
+  /** minimum number of days before able to change account's password */
+  minPasswordAge?: number | null;
+  /** minimum number of characters password must contain */
+  minPasswordLength?: number | null;
+  /** Spam and Antivirus configuration */
+  spamAndVirusConfiguration?: IamResourceTagFilterInput;
+}
+export const PutEmailProRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    complexityEnabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    lockoutDuration: S.optional(S.Number),
+    lockoutObservationWindow: S.optional(S.Number),
+    lockoutThreshold: S.optional(S.NullOr(S.Number)),
+    maxPasswordAge: S.optional(S.NullOr(S.Number)),
+    maxReceiveSize: S.optional(S.Number),
+    maxSendSize: S.optional(S.Number),
+    minPasswordAge: S.optional(S.NullOr(S.Number)),
+    minPasswordLength: S.optional(S.NullOr(S.Number)),
+    spamAndVirusConfiguration: S.optional(IamResourceTagFilterInput),
+  }).pipe(T.Http({ method: "PUT", uri: "/email/pro/{service}", code: 200 })),
+).annotate({
+  identifier: "PutEmailProRequest",
+}) as any as S.Schema<PutEmailProRequest>;
+
+export interface PutEmailProResponse {}
+export const PutEmailProResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailProResponse",
+}) as any as S.Schema<PutEmailProResponse>;
+
+/** Enable or disable anti-virus and anti-spam */
+export type PutEmailProAccountRequestMailingFilterList = Array<
+  EmailProMailingFilterEnum | (string & {})
+>;
+export const PutEmailProAccountRequestMailingFilterList = /*@__PURE__*/ S.Array(
+  EmailProMailingFilterEnum,
+) as any as S.Schema<PutEmailProAccountRequestMailingFilterList>;
+
+export interface PutEmailProAccountRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** delete at expiration */
+  deleteAtExpiration?: boolean | null;
+  /** Account display name */
+  displayName?: string | null;
+  /** Email domain */
+  domain?: string;
+  /** Account first name */
+  firstName?: string | null;
+  /** Hide account in Global Address List */
+  hiddenFromGAL?: boolean;
+  /** Account initials */
+  initial?: string | null;
+  /** Account last name */
+  lastName?: string | null;
+  /** Account login */
+  login?: string;
+  /** Enable or disable anti-virus and anti-spam */
+  mailingFilter?: PutEmailProAccountRequestMailingFilterList | null;
+  /** Account maximum size */
+  quota?: number;
+  /** change the renew period */
+  renewPeriod?: EmailProRenewPeriodEnum | (string & {}) | null;
+  /** Spam and Antivirus configuration */
+  spamAndVirusConfiguration?: IamResourceTagFilterInput;
+}
+export const PutEmailProAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    deleteAtExpiration: S.optional(S.NullOr(S.Boolean)),
+    displayName: S.optional(S.NullOr(S.String)),
+    domain: S.optional(S.String),
+    firstName: S.optional(S.NullOr(S.String)),
+    hiddenFromGAL: S.optional(S.Boolean),
+    initial: S.optional(S.NullOr(S.String)),
+    lastName: S.optional(S.NullOr(S.String)),
+    login: S.optional(S.String),
+    mailingFilter: S.optional(
+      S.NullOr(PutEmailProAccountRequestMailingFilterList),
+    ),
+    quota: S.optional(S.Number),
+    renewPeriod: S.optional(S.NullOr(EmailProRenewPeriodEnum)),
+    spamAndVirusConfiguration: S.optional(IamResourceTagFilterInput),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/email/pro/{service}/account/{email}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailProAccountRequest",
+}) as any as S.Schema<PutEmailProAccountRequest>;
+
+export interface PutEmailProAccountResponse {}
+export const PutEmailProAccountResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailProAccountResponse",
+}) as any as S.Schema<PutEmailProAccountResponse>;
+
+export interface PutEmailProDomainRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** If specified, emails to not existing address will be redirected to that domain */
+  mxRelay?: string | null;
+  /** Domain type */
+  type?: EmailProDomainTypeEnum | (string & {});
+}
+export const PutEmailProDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    mxRelay: S.optional(S.NullOr(S.String)),
+    type: S.optional(EmailProDomainTypeEnum),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/email/pro/{service}/domain/{domainName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailProDomainRequest",
+}) as any as S.Schema<PutEmailProDomainRequest>;
+
+export interface PutEmailProDomainResponse {}
+export const PutEmailProDomainResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailProDomainResponse",
+}) as any as S.Schema<PutEmailProDomainResponse>;
+
+export interface PutEmailProDomainDisclaimerRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+  /** Signature, added at the bottom of your organization emails */
+  content?: string;
+  /** Activate the disclaimer only for external emails */
+  outsideOnly?: boolean;
+}
+export const PutEmailProDomainDisclaimerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+    content: S.optional(S.String),
+    outsideOnly: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/email/pro/{service}/domain/{domainName}/disclaimer",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailProDomainDisclaimerRequest",
+}) as any as S.Schema<PutEmailProDomainDisclaimerRequest>;
+
+export interface PutEmailProDomainDisclaimerResponse {}
+export const PutEmailProDomainDisclaimerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailProDomainDisclaimerResponse",
+}) as any as S.Schema<PutEmailProDomainDisclaimerResponse>;
+
+export interface PutEmailProExternalContactRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Contact email */
+  externalEmailAddress: string;
+  /** Contact display name */
+  displayName?: string;
+  /** Contact first name */
+  firstName?: string | null;
+  /** Hide the contact in Global Address List */
+  hiddenFromGAL?: boolean;
+  /** Contact initals */
+  initials?: string | null;
+  /** Contact last name */
+  lastName?: string | null;
+}
+export const PutEmailProExternalContactRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    externalEmailAddress: S.String.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    firstName: S.optional(S.NullOr(S.String)),
+    hiddenFromGAL: S.optional(S.Boolean),
+    initials: S.optional(S.NullOr(S.String)),
+    lastName: S.optional(S.NullOr(S.String)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/email/pro/{service}/externalContact/{externalEmailAddress}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailProExternalContactRequest",
+}) as any as S.Schema<PutEmailProExternalContactRequest>;
+
+export interface PutEmailProExternalContactResponse {}
+export const PutEmailProExternalContactResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailProExternalContactResponse",
+}) as any as S.Schema<PutEmailProExternalContactResponse>;
+
+export interface PutEmailProServiceInfosRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutEmailProServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/email/pro/{service}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailProServiceInfosRequest",
+}) as any as S.Schema<PutEmailProServiceInfosRequest>;
+
+export interface PutEmailProServiceInfosResponse {}
+export const PutEmailProServiceInfosResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailProServiceInfosResponse",
+}) as any as S.Schema<PutEmailProServiceInfosResponse>;
+
+export interface SendEmailProAccountAsRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to allow to send mails from this mailbox */
+  allowAccountId: number;
+}
+export const SendEmailProAccountAsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+    allowAccountId: S.Number,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/account/{email}/sendAs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SendEmailProAccountAsRequest",
+}) as any as S.Schema<SendEmailProAccountAsRequest>;
+
+export interface SendEmailProAccountOnBehalfToRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to allow to send On Behalf To mails from this mailbox */
+  allowAccountId: number;
+}
+export const SendEmailProAccountOnBehalfToRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+      allowAccountId: S.Number,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/account/{email}/sendOnBehalfTo",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "SendEmailProAccountOnBehalfToRequest",
+}) as any as S.Schema<SendEmailProAccountOnBehalfToRequest>;
+
+export interface TerminateEmailProAccountRequest {
+  /** The internal name of your pro organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const TerminateEmailProAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/email/pro/{service}/account/{email}/terminate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TerminateEmailProAccountRequest",
+}) as any as S.Schema<TerminateEmailProAccountRequest>;
+
+export type TerminateEmailProAccountResponse = string;
+export const TerminateEmailProAccountResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateEmailProAccountResponse",
+}) as any as S.Schema<TerminateEmailProAccountResponse>;
+
+export interface UpdateEmailProFlagsOnAllAccountsRequest {
+  /** The internal name of your pro organization */
+  service: string;
+}
+export const UpdateEmailProFlagsOnAllAccountsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/pro/{service}/updateFlagsOnAllAccounts",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "UpdateEmailProFlagsOnAllAccountsRequest",
+}) as any as S.Schema<UpdateEmailProFlagsOnAllAccountsRequest>;
+
+export interface UpdateEmailProFlagsOnAllAccountsResponse {}
+export const UpdateEmailProFlagsOnAllAccountsResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "UpdateEmailProFlagsOnAllAccountsResponse",
+}) as any as S.Schema<UpdateEmailProFlagsOnAllAccountsResponse>;
+
+export type CreateEmailProAccountAliasError = OvhOpError;
+/** Create new alias */
+export const createEmailProAccountAlias: API.OperationMethod<
+  CreateEmailProAccountAliasRequest,
+  EmailProTask,
+  CreateEmailProAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProAccountAliasRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProAccountChangePasswordError = OvhOpError;
+/** Change mailbox password */
+export const createEmailProAccountChangePassword: API.OperationMethod<
+  CreateEmailProAccountChangePasswordRequest,
+  EmailProTask,
+  CreateEmailProAccountChangePasswordError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProAccountChangePasswordRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProAccountDiagnosticError = OvhOpError;
+/** Create new diagnosis request */
+export const createEmailProAccountDiagnostic: API.OperationMethod<
+  CreateEmailProAccountDiagnosticRequest,
+  EmailProTask,
+  CreateEmailProAccountDiagnosticError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProAccountDiagnosticRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProAccountFullAccessError = OvhOpError;
+/** Allow full access to a user */
+export const createEmailProAccountFullAccess: API.OperationMethod<
+  CreateEmailProAccountFullAccessRequest,
+  EmailProTask,
+  CreateEmailProAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProAccountFullAccessRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createEmailProChangeContact: API.OperationMethod<
+  CreateEmailProChangeContactRequest,
+  CreateEmailProChangeContactResponse,
+  CreateEmailProChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProChangeContactRequest,
+  output: CreateEmailProChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProDomainError = OvhOpError;
+/** Create new domain in pro services */
+export const createEmailProDomain: API.OperationMethod<
+  CreateEmailProDomainRequest,
+  EmailProTask,
+  CreateEmailProDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProDomainRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProDomainDisclaimerError = OvhOpError;
+/** Create organization disclaimer of each email */
+export const createEmailProDomainDisclaimer: API.OperationMethod<
+  CreateEmailProDomainDisclaimerRequest,
+  EmailProTask,
+  CreateEmailProDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProDomainDisclaimerRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProDomainDkimError = OvhOpError;
+/** Create DKIM selector on this domain */
+export const createEmailProDomainDkim: API.OperationMethod<
+  CreateEmailProDomainDkimRequest,
+  EmailProTask,
+  CreateEmailProDomainDkimError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProDomainDkimRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailProExternalContactError = OvhOpError;
+/** create new external contact */
+export const createEmailProExternalContact: API.OperationMethod<
+  CreateEmailProExternalContactRequest,
+  EmailProTask,
+  CreateEmailProExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailProExternalContactRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProAccountError = OvhOpError;
+/** Delete existing mailbox in pro server */
+export const deleteEmailProAccount: API.OperationMethod<
+  DeleteEmailProAccountRequest,
+  EmailProTask,
+  DeleteEmailProAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProAccountRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProAccountAliasError = OvhOpError;
+/** Delete existing alias */
+export const deleteEmailProAccountAlias: API.OperationMethod<
+  DeleteEmailProAccountAliasRequest,
+  EmailProTask,
+  DeleteEmailProAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProAccountAliasRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProAccountFullAccessError = OvhOpError;
+/** Revoke full access */
+export const deleteEmailProAccountFullAccess: API.OperationMethod<
+  DeleteEmailProAccountFullAccessRequest,
+  EmailProTask,
+  DeleteEmailProAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProAccountFullAccessRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProAccountSendAsError = OvhOpError;
+/** Delete allowed user for sendAs */
+export const deleteEmailProAccountSendAs: API.OperationMethod<
+  DeleteEmailProAccountSendAsRequest,
+  EmailProTask,
+  DeleteEmailProAccountSendAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProAccountSendAsRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProAccountSendOnBehalfToError = OvhOpError;
+/** Delete allowed user for SendOnBehalfTo */
+export const deleteEmailProAccountSendOnBehalfTo: API.OperationMethod<
+  DeleteEmailProAccountSendOnBehalfToRequest,
+  EmailProTask,
+  DeleteEmailProAccountSendOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProAccountSendOnBehalfToRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProDomainError = OvhOpError;
+/** Delete existing domain in pro services */
+export const deleteEmailProDomain: API.OperationMethod<
+  DeleteEmailProDomainRequest,
+  EmailProTask,
+  DeleteEmailProDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProDomainRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProDomainDisclaimerError = OvhOpError;
+/** Delete existing organization disclaimer */
+export const deleteEmailProDomainDisclaimer: API.OperationMethod<
+  DeleteEmailProDomainDisclaimerRequest,
+  EmailProTask,
+  DeleteEmailProDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProDomainDisclaimerRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProDomainDkimError = OvhOpError;
+/** Delete DKIM selector on this domain */
+export const deleteEmailProDomainDkim: API.OperationMethod<
+  DeleteEmailProDomainDkimRequest,
+  EmailProTask,
+  DeleteEmailProDomainDkimError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProDomainDkimRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailProExternalContactError = OvhOpError;
+/** delete external contact */
+export const deleteEmailProExternalContact: API.OperationMethod<
+  DeleteEmailProExternalContactRequest,
+  EmailProTask,
+  DeleteEmailProExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailProExternalContactRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableEmailProDomainDkimError = OvhOpError;
+/** disable dkim signing */
+export const disableEmailProDomainDkim: API.OperationMethod<
+  DisableEmailProDomainDkimRequest,
+  EmailProTask,
+  DisableEmailProDomainDkimError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DisableEmailProDomainDkimRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EnableEmailProDomainDkimError = OvhOpError;
+/** enable dkim signing or switch selector used */
+export const enableEmailProDomainDkim: API.OperationMethod<
+  EnableEmailProDomainDkimRequest,
+  EmailProTask,
+  EnableEmailProDomainDkimError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EnableEmailProDomainDkimRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProError = OvhOpError;
+/** Get this object properties */
+export const getEmailPro: API.OperationMethod<
+  GetEmailProRequest,
+  EmailProServiceNativeWithIAM,
+  GetEmailProError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProRequest,
+  output: EmailProServiceNativeWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccount: API.OperationMethod<
+  GetEmailProAccountRequest,
+  EmailProAccountNative,
+  GetEmailProAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountRequest,
+  output: EmailProAccountNative,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountAliasError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccountAlias: API.OperationMethod<
+  GetEmailProAccountAliasRequest,
+  EmailProAccountAlias,
+  GetEmailProAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountAliasRequest,
+  output: EmailProAccountAlias,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountDiagnosticsError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccountDiagnostics: API.OperationMethod<
+  GetEmailProAccountDiagnosticsRequest,
+  EmailProAccountDiagnosis,
+  GetEmailProAccountDiagnosticsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountDiagnosticsRequest,
+  output: EmailProAccountDiagnosis,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountFullAccessError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccountFullAccess: API.OperationMethod<
+  GetEmailProAccountFullAccessRequest,
+  EmailProAccountFullAccess,
+  GetEmailProAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountFullAccessRequest,
+  output: EmailProAccountFullAccess,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountSendAsError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccountSendAs: API.OperationMethod<
+  GetEmailProAccountSendAsRequest,
+  EmailProAccountSendAs,
+  GetEmailProAccountSendAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountSendAsRequest,
+  output: EmailProAccountSendAs,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountSendOnBehalfToError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccountSendOnBehalfTo: API.OperationMethod<
+  GetEmailProAccountSendOnBehalfToRequest,
+  EmailProAccountSendOnBehalfTo,
+  GetEmailProAccountSendOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountSendOnBehalfToRequest,
+  output: EmailProAccountSendOnBehalfTo,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProAccountTaskError = OvhOpError;
+/** Get this object properties */
+export const getEmailProAccountTask: API.OperationMethod<
+  GetEmailProAccountTaskRequest,
+  EmailProTask,
+  GetEmailProAccountTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProAccountTaskRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProBillingMigratedError = OvhOpError;
+/** Detects billing transition status for the service */
+export const getEmailProBillingMigrated: API.OperationMethod<
+  GetEmailProBillingMigratedRequest,
+  GetEmailProBillingMigratedResponse,
+  GetEmailProBillingMigratedError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProBillingMigratedRequest,
+  output: GetEmailProBillingMigratedResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProBillingPlanError = OvhOpError;
+/** Emailpro billing plan */
+export const getEmailProBillingPlan: API.OperationMethod<
+  GetEmailProBillingPlanRequest,
+  GetEmailProBillingPlanResponse,
+  GetEmailProBillingPlanError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProBillingPlanRequest,
+  output: GetEmailProBillingPlanResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProDomainError = OvhOpError;
+/** Get this object properties */
+export const getEmailProDomain: API.OperationMethod<
+  GetEmailProDomainRequest,
+  EmailProDomainNative,
+  GetEmailProDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProDomainRequest,
+  output: EmailProDomainNative,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProDomainDisclaimerError = OvhOpError;
+/** Get this object properties */
+export const getEmailProDomainDisclaimer: API.OperationMethod<
+  GetEmailProDomainDisclaimerRequest,
+  EmailProDisclaimerNative,
+  GetEmailProDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProDomainDisclaimerRequest,
+  output: EmailProDisclaimerNative,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProDomainDkimError = OvhOpError;
+/** Get this object properties */
+export const getEmailProDomainDkim: API.OperationMethod<
+  GetEmailProDomainDkimRequest,
+  EmailProDkim,
+  GetEmailProDomainDkimError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProDomainDkimRequest,
+  output: EmailProDkim,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProExternalContactError = OvhOpError;
+/** Get this object properties */
+export const getEmailProExternalContact: API.OperationMethod<
+  GetEmailProExternalContactRequest,
+  EmailProExternalContactNative,
+  GetEmailProExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProExternalContactRequest,
+  output: EmailProExternalContactNative,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProServerError = OvhOpError;
+/** Get this object properties */
+export const getEmailProServer: API.OperationMethod<
+  GetEmailProServerRequest,
+  EmailProServer,
+  GetEmailProServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProServerRequest,
+  output: EmailProServer,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProServiceInfosError = OvhOpError;
+/** Get service information */
+export const getEmailProServiceInfos: API.OperationMethod<
+  GetEmailProServiceInfosRequest,
+  ServicesService,
+  GetEmailProServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailProTaskError = OvhOpError;
+/** Get this object properties */
+export const getEmailProTask: API.OperationMethod<
+  GetEmailProTaskRequest,
+  EmailProTask,
+  GetEmailProTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailProTaskRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProError = OvhOpError;
+/** List available services */
+export const listEmailPro: API.OperationMethod<
+  ListEmailProRequest,
+  ListEmailProResponse,
+  ListEmailProError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProRequest,
+  output: ListEmailProResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProAccountError = OvhOpError;
+/** Accounts associated to this pro service */
+export const listEmailProAccount: API.OperationMethod<
+  ListEmailProAccountRequest,
+  ListEmailProAccountResponse,
+  ListEmailProAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProAccountRequest,
+  output: ListEmailProAccountResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProAccountAliasError = OvhOpError;
+/** Aliases associated to this mailbox */
+export const listEmailProAccountAlias: API.OperationMethod<
+  ListEmailProAccountAliasRequest,
+  ListEmailProAccountAliasResponse,
+  ListEmailProAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProAccountAliasRequest,
+  output: ListEmailProAccountAliasResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProAccountFullAccessError = OvhOpError;
+/** Full access granted users for this mailbox */
+export const listEmailProAccountFullAccess: API.OperationMethod<
+  ListEmailProAccountFullAccessRequest,
+  ListEmailProAccountFullAccessResponse,
+  ListEmailProAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProAccountFullAccessRequest,
+  output: ListEmailProAccountFullAccessResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProAccountSendAsError = OvhOpError;
+/** Send as granted users for this mailbox */
+export const listEmailProAccountSendAs: API.OperationMethod<
+  ListEmailProAccountSendAsRequest,
+  ListEmailProAccountSendAsResponse,
+  ListEmailProAccountSendAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProAccountSendAsRequest,
+  output: ListEmailProAccountSendAsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProAccountSendOnBehalfToError = OvhOpError;
+/** SendOnBehalfTo granted users for this mailbox */
+export const listEmailProAccountSendOnBehalfTo: API.OperationMethod<
+  ListEmailProAccountSendOnBehalfToRequest,
+  ListEmailProAccountSendOnBehalfToResponse,
+  ListEmailProAccountSendOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProAccountSendOnBehalfToRequest,
+  output: ListEmailProAccountSendOnBehalfToResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProAccountTasksError = OvhOpError;
+/** Pending task for this mailbox */
+export const listEmailProAccountTasks: API.OperationMethod<
+  ListEmailProAccountTasksRequest,
+  ListEmailProAccountTasksResponse,
+  ListEmailProAccountTasksError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProAccountTasksRequest,
+  output: ListEmailProAccountTasksResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProDomainError = OvhOpError;
+/** Domains associated to this service */
+export const listEmailProDomain: API.OperationMethod<
+  ListEmailProDomainRequest,
+  ListEmailProDomainResponse,
+  ListEmailProDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProDomainRequest,
+  output: ListEmailProDomainResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProDomainDisclaimerAttributeError = OvhOpError;
+/** Get diclaimer attributes to substitute with Active Directory properties */
+export const listEmailProDomainDisclaimerAttribute: API.OperationMethod<
+  ListEmailProDomainDisclaimerAttributeRequest,
+  ListEmailProDomainDisclaimerAttributeResponse,
+  ListEmailProDomainDisclaimerAttributeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProDomainDisclaimerAttributeRequest,
+  output: ListEmailProDomainDisclaimerAttributeResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProDomainDkimError = OvhOpError;
+/** DKIM associated to this domain */
+export const listEmailProDomainDkim: API.OperationMethod<
+  ListEmailProDomainDkimRequest,
+  ListEmailProDomainDkimResponse,
+  ListEmailProDomainDkimError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProDomainDkimRequest,
+  output: ListEmailProDomainDkimResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProDomainDkimSelectorError = OvhOpError;
+/** Get dkim selector list */
+export const listEmailProDomainDkimSelector: API.OperationMethod<
+  ListEmailProDomainDkimSelectorRequest,
+  ListEmailProDomainDkimSelectorResponse,
+  ListEmailProDomainDkimSelectorError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProDomainDkimSelectorRequest,
+  output: ListEmailProDomainDkimSelectorResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProExternalContactError = OvhOpError;
+/** External contacts for this service */
+export const listEmailProExternalContact: API.OperationMethod<
+  ListEmailProExternalContactRequest,
+  ListEmailProExternalContactResponse,
+  ListEmailProExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProExternalContactRequest,
+  output: ListEmailProExternalContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailProTaskError = OvhOpError;
+/** Pending actions */
+export const listEmailProTask: API.OperationMethod<
+  ListEmailProTaskRequest,
+  ListEmailProTaskResponse,
+  ListEmailProTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailProTaskRequest,
+  output: ListEmailProTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailProError = OvhOpError;
+/** Alter this object properties */
+export const putEmailPro: API.OperationMethod<
+  PutEmailProRequest,
+  PutEmailProResponse,
+  PutEmailProError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailProRequest,
+  output: PutEmailProResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailProAccountError = OvhOpError;
+/** Alter this object properties */
+export const putEmailProAccount: API.OperationMethod<
+  PutEmailProAccountRequest,
+  PutEmailProAccountResponse,
+  PutEmailProAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailProAccountRequest,
+  output: PutEmailProAccountResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailProDomainError = OvhOpError;
+/** Alter this object properties */
+export const putEmailProDomain: API.OperationMethod<
+  PutEmailProDomainRequest,
+  PutEmailProDomainResponse,
+  PutEmailProDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailProDomainRequest,
+  output: PutEmailProDomainResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailProDomainDisclaimerError = OvhOpError;
+/** Alter this object properties */
+export const putEmailProDomainDisclaimer: API.OperationMethod<
+  PutEmailProDomainDisclaimerRequest,
+  PutEmailProDomainDisclaimerResponse,
+  PutEmailProDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailProDomainDisclaimerRequest,
+  output: PutEmailProDomainDisclaimerResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailProExternalContactError = OvhOpError;
+/** Alter this object properties */
+export const putEmailProExternalContact: API.OperationMethod<
+  PutEmailProExternalContactRequest,
+  PutEmailProExternalContactResponse,
+  PutEmailProExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailProExternalContactRequest,
+  output: PutEmailProExternalContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailProServiceInfosError = OvhOpError;
+/** Update service information */
+export const putEmailProServiceInfos: API.OperationMethod<
+  PutEmailProServiceInfosRequest,
+  PutEmailProServiceInfosResponse,
+  PutEmailProServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailProServiceInfosRequest,
+  output: PutEmailProServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SendEmailProAccountAsError = OvhOpError;
+/** Allow another user to send mails from this mailbox */
+export const sendEmailProAccountAs: API.OperationMethod<
+  SendEmailProAccountAsRequest,
+  EmailProTask,
+  SendEmailProAccountAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SendEmailProAccountAsRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SendEmailProAccountOnBehalfToError = OvhOpError;
+/** Allow another user to Send On Behalf To mails from this mailbox */
+export const sendEmailProAccountOnBehalfTo: API.OperationMethod<
+  SendEmailProAccountOnBehalfToRequest,
+  EmailProTask,
+  SendEmailProAccountOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SendEmailProAccountOnBehalfToRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateEmailProAccountError = OvhOpError;
+/** Terminate account at expiration date */
+export const terminateEmailProAccount: API.OperationMethod<
+  TerminateEmailProAccountRequest,
+  TerminateEmailProAccountResponse,
+  TerminateEmailProAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateEmailProAccountRequest,
+  output: TerminateEmailProAccountResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateEmailProFlagsOnAllAccountsError = OvhOpError;
+/** Update spam and virus flags on all active accounts */
+export const updateEmailProFlagsOnAllAccounts: API.OperationMethod<
+  UpdateEmailProFlagsOnAllAccountsRequest,
+  UpdateEmailProFlagsOnAllAccountsResponse,
+  UpdateEmailProFlagsOnAllAccountsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateEmailProFlagsOnAllAccountsRequest,
+  output: UpdateEmailProFlagsOnAllAccountsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));