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

package/src/services/emailmxplan.ts

@@ -0,0 +1,2764 @@
+// 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 CreateEmailMxplanAccountAliasRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Alias */
+  alias: string;
+}
+export const CreateEmailMxplanAccountAliasRequest = /*@__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/mxplan/{service}/account/{email}/alias",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailMxplanAccountAliasRequest",
+}) as any as S.Schema<CreateEmailMxplanAccountAliasRequest>;
+
+/** 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 CreateEmailMxplanAccountChangePasswordRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** new password */
+  password: string | Redacted.Redacted<string>;
+}
+export const CreateEmailMxplanAccountChangePasswordRequest =
+  /*@__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/mxplan/{service}/account/{email}/changePassword",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateEmailMxplanAccountChangePasswordRequest",
+  }) as any as S.Schema<CreateEmailMxplanAccountChangePasswordRequest>;
+
+export interface CreateEmailMxplanAccountDiagnosticRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account password */
+  password: string | Redacted.Redacted<string>;
+}
+export const CreateEmailMxplanAccountDiagnosticRequest =
+  /*@__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/mxplan/{service}/account/{email}/diagnostic",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateEmailMxplanAccountDiagnosticRequest",
+  }) as any as S.Schema<CreateEmailMxplanAccountDiagnosticRequest>;
+
+export interface CreateEmailMxplanAccountFullAccessRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** User to give full access */
+  allowedAccountId: number;
+}
+export const CreateEmailMxplanAccountFullAccessRequest =
+  /*@__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/mxplan/{service}/account/{email}/fullAccess",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateEmailMxplanAccountFullAccessRequest",
+  }) as any as S.Schema<CreateEmailMxplanAccountFullAccessRequest>;
+
+export interface CreateEmailMxplanDomainDisclaimerRequest {
+  /** The internal name of your mxplan 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 CreateEmailMxplanDomainDisclaimerRequest = /*@__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/mxplan/{service}/domain/{domainName}/disclaimer",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailMxplanDomainDisclaimerRequest",
+}) as any as S.Schema<CreateEmailMxplanDomainDisclaimerRequest>;
+
+export interface CreateEmailMxplanExternalContactRequest {
+  /** The internal name of your mxplan 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 CreateEmailMxplanExternalContactRequest = /*@__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/mxplan/{service}/externalContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateEmailMxplanExternalContactRequest",
+}) as any as S.Schema<CreateEmailMxplanExternalContactRequest>;
+
+export interface DeleteEmailMxplanAccountRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const DeleteEmailMxplanAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/email/mxplan/{service}/account/{email}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteEmailMxplanAccountRequest",
+}) as any as S.Schema<DeleteEmailMxplanAccountRequest>;
+
+export interface DeleteEmailMxplanAccountAliasRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Alias */
+  alias: string;
+}
+export const DeleteEmailMxplanAccountAliasRequest = /*@__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/mxplan/{service}/account/{email}/alias/{alias}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailMxplanAccountAliasRequest",
+}) as any as S.Schema<DeleteEmailMxplanAccountAliasRequest>;
+
+export interface DeleteEmailMxplanAccountFullAccessRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give full access */
+  allowedAccountId: number;
+}
+export const DeleteEmailMxplanAccountFullAccessRequest =
+  /*@__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/mxplan/{service}/account/{email}/fullAccess/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteEmailMxplanAccountFullAccessRequest",
+  }) as any as S.Schema<DeleteEmailMxplanAccountFullAccessRequest>;
+
+export interface DeleteEmailMxplanAccountSendAsRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give send as */
+  allowedAccountId: number;
+}
+export const DeleteEmailMxplanAccountSendAsRequest = /*@__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/mxplan/{service}/account/{email}/sendAs/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailMxplanAccountSendAsRequest",
+}) as any as S.Schema<DeleteEmailMxplanAccountSendAsRequest>;
+
+export interface DeleteEmailMxplanAccountSendOnBehalfToRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give send on behalf to */
+  allowedAccountId: number;
+}
+export const DeleteEmailMxplanAccountSendOnBehalfToRequest =
+  /*@__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/mxplan/{service}/account/{email}/sendOnBehalfTo/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteEmailMxplanAccountSendOnBehalfToRequest",
+  }) as any as S.Schema<DeleteEmailMxplanAccountSendOnBehalfToRequest>;
+
+export interface DeleteEmailMxplanDomainDisclaimerRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const DeleteEmailMxplanDomainDisclaimerRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/email/mxplan/{service}/domain/{domainName}/disclaimer",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailMxplanDomainDisclaimerRequest",
+}) as any as S.Schema<DeleteEmailMxplanDomainDisclaimerRequest>;
+
+export interface DeleteEmailMxplanExternalContactRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Contact email */
+  externalEmailAddress: string;
+}
+export const DeleteEmailMxplanExternalContactRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      externalEmailAddress: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/email/mxplan/{service}/externalContact/{externalEmailAddress}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteEmailMxplanExternalContactRequest",
+}) as any as S.Schema<DeleteEmailMxplanExternalContactRequest>;
+
+export interface GetEmailMxplanRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+}
+export const GetEmailMxplanRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/email/mxplan/{service}", code: 200 })),
+).annotate({
+  identifier: "GetEmailMxplanRequest",
+}) as any as S.Schema<GetEmailMxplanRequest>;
+
+/** 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 EmailMxplanServiceOfferEnum = "MXPLAN";
+export const EmailMxplanServiceOfferEnum = /*@__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;
+
+/** MXPlan service */
+export interface EmailMxplanServiceWithIAM {
+  /** 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;
+  /** Service use Zimbra as backend */
+  isZimbra?: boolean;
+  /** 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?: EmailMxplanServiceOfferEnum;
+  /** 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 EmailMxplanServiceWithIAM = /*@__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)),
+    isZimbra: S.optional(S.Boolean),
+    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(EmailMxplanServiceOfferEnum),
+    spamAndVirusConfiguration: S.optional(EmailProSpamAndVirusConfiguration),
+    state: S.optional(EmailProServiceStateEnum),
+    taskPendingId: S.optional(S.Number),
+    webUrl: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "EmailMxplanServiceWithIAM",
+}) as any as S.Schema<EmailMxplanServiceWithIAM>;
+
+export interface GetEmailMxplanAccountRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const GetEmailMxplanAccountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/mxplan/{service}/account/{email}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanAccountRequest",
+}) as any as S.Schema<GetEmailMxplanAccountRequest>;
+
+/** Mailing filter options availlable */
+export type EmailProMailingFilterEnum = "vaderetro";
+export const EmailProMailingFilterEnum = /*@__PURE__*/ S.String;
+
+/** Enable or disable anti-virus and anti-spam */
+export type EmailMxplanAccountMailingFilterList =
+  Array<EmailProMailingFilterEnum>;
+export const EmailMxplanAccountMailingFilterList = /*@__PURE__*/ S.Array(
+  EmailProMailingFilterEnum,
+) as any as S.Schema<EmailMxplanAccountMailingFilterList>;
+
+/** 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 EmailMxplanAccount {
+  /** 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?: EmailMxplanAccountMailingFilterList | 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 EmailMxplanAccount = /*@__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(EmailMxplanAccountMailingFilterList)),
+    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: "EmailMxplanAccount",
+}) as any as S.Schema<EmailMxplanAccount>;
+
+export interface GetEmailMxplanAccountAliasRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Alias */
+  alias: string;
+}
+export const GetEmailMxplanAccountAliasRequest = /*@__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/mxplan/{service}/account/{email}/alias/{alias}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanAccountAliasRequest",
+}) as any as S.Schema<GetEmailMxplanAccountAliasRequest>;
+
+/** Aliases on this mailbox */
+export interface EmailMxplanAccountAlias {
+  /** Alias */
+  alias?: string;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailMxplanAccountAlias = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    alias: S.optional(S.String),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailMxplanAccountAlias",
+}) as any as S.Schema<EmailMxplanAccountAlias>;
+
+export interface GetEmailMxplanAccountDiagnosticRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const GetEmailMxplanAccountDiagnosticRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/account/{email}/diagnostic",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetEmailMxplanAccountDiagnosticRequest",
+}) as any as S.Schema<GetEmailMxplanAccountDiagnosticRequest>;
+
+/** Account Diagnosis */
+export interface EmailMxplanAccountDiagnosis {
+  /** 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 EmailMxplanAccountDiagnosis = /*@__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: "EmailMxplanAccountDiagnosis",
+}) as any as S.Schema<EmailMxplanAccountDiagnosis>;
+
+export interface GetEmailMxplanAccountFullAccessRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give full access */
+  allowedAccountId: number;
+}
+export const GetEmailMxplanAccountFullAccessRequest = /*@__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/mxplan/{service}/account/{email}/fullAccess/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetEmailMxplanAccountFullAccessRequest",
+}) as any as S.Schema<GetEmailMxplanAccountFullAccessRequest>;
+
+/** Users having full access on this mailbox */
+export interface EmailMxplanAccountFullAccess {
+  /** Account id to give full access */
+  allowedAccountId?: number;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailMxplanAccountFullAccess = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedAccountId: S.optional(S.Number),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailMxplanAccountFullAccess",
+}) as any as S.Schema<EmailMxplanAccountFullAccess>;
+
+export interface GetEmailMxplanAccountSendAsRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give send as */
+  allowedAccountId: number;
+}
+export const GetEmailMxplanAccountSendAsRequest = /*@__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/mxplan/{service}/account/{email}/sendAs/{allowedAccountId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanAccountSendAsRequest",
+}) as any as S.Schema<GetEmailMxplanAccountSendAsRequest>;
+
+/** Users authorized to send mails from this mailbox */
+export interface EmailMxplanAccountSendAs {
+  /** Account id to give send as */
+  allowedAccountId?: number;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailMxplanAccountSendAs = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedAccountId: S.optional(S.Number),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailMxplanAccountSendAs",
+}) as any as S.Schema<EmailMxplanAccountSendAs>;
+
+export interface GetEmailMxplanAccountSendOnBehalfToRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to give send on behalf to */
+  allowedAccountId: number;
+}
+export const GetEmailMxplanAccountSendOnBehalfToRequest =
+  /*@__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/mxplan/{service}/account/{email}/sendOnBehalfTo/{allowedAccountId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetEmailMxplanAccountSendOnBehalfToRequest",
+  }) as any as S.Schema<GetEmailMxplanAccountSendOnBehalfToRequest>;
+
+/** Get users authorized to Send On Behalf To mails from this mailbox */
+export interface EmailMxplanAccountSendOnBehalfTo {
+  /** Account id to give send on behalf to */
+  allowedAccountId?: number;
+  /** Creation date */
+  creationDate?: string;
+  /** Pending task id */
+  taskPendingId?: number;
+}
+export const EmailMxplanAccountSendOnBehalfTo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedAccountId: S.optional(S.Number),
+    creationDate: S.optional(S.String),
+    taskPendingId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "EmailMxplanAccountSendOnBehalfTo",
+}) as any as S.Schema<EmailMxplanAccountSendOnBehalfTo>;
+
+export interface GetEmailMxplanAccountTaskRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Task id */
+  id: number;
+}
+export const GetEmailMxplanAccountTaskRequest = /*@__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/mxplan/{service}/account/{email}/task/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanAccountTaskRequest",
+}) as any as S.Schema<GetEmailMxplanAccountTaskRequest>;
+
+export interface GetEmailMxplanDomainRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const GetEmailMxplanDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    domainName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/mxplan/{service}/domain/{domainName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanDomainRequest",
+}) as any as S.Schema<GetEmailMxplanDomainRequest>;
+
+/** List of aliases for this domain */
+export type EmailMxplanDomainDomainAliasesList = Array<string>;
+export const EmailMxplanDomainDomainAliasesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailMxplanDomainDomainAliasesList>;
+
+/** Expected MX record(s) on this domain */
+export type EmailMxplanDomainExpectedMXList = Array<string>;
+export const EmailMxplanDomainExpectedMXList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailMxplanDomainExpectedMXList>;
+
+/** Domain MX record configured in DNS */
+export type EmailMxplanDomainMxRecordList = Array<string>;
+export const EmailMxplanDomainMxRecordList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailMxplanDomainMxRecordList>;
+
+/** Domain SRV record configured in DNS */
+export type EmailMxplanDomainSrvRecordList = Array<string>;
+export const EmailMxplanDomainSrvRecordList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EmailMxplanDomainSrvRecordList>;
+
+/** Domain type */
+export type EmailProDomainTypeEnum = "authoritative" | "nonAuthoritative";
+export const EmailProDomainTypeEnum = /*@__PURE__*/ S.String;
+
+/** Domain */
+export interface EmailMxplanDomain {
+  /** Cname that will be checked to prove the domain ownership */
+  cnameToCheck?: string | null;
+  /** List of aliases for this domain */
+  domainAliases?: EmailMxplanDomainDomainAliasesList;
+  /** Domain validation status */
+  domainValidated?: boolean;
+  /** Expected MX record(s) on this domain */
+  expectedMX?: EmailMxplanDomainExpectedMXList;
+  /** 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?: EmailMxplanDomainMxRecordList;
+  /** If specified, emails to not existing address will be redirected to that domain */
+  mxRelay?: string | null;
+  /** Domain name */
+  name?: string;
+  /** If true your dns srv record is valid */
+  srvIsValid?: boolean;
+  /** Domain SRV record configured in DNS */
+  srvRecord?: EmailMxplanDomainSrvRecordList;
+  /** Domain state */
+  state?: EmailProObjectStateEnum;
+  /** Pending taks id */
+  taskPendingId?: number;
+  /** Domain type */
+  type?: EmailProDomainTypeEnum;
+}
+export const EmailMxplanDomain = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cnameToCheck: S.optional(S.NullOr(S.String)),
+    domainAliases: S.optional(EmailMxplanDomainDomainAliasesList),
+    domainValidated: S.optional(S.Boolean),
+    expectedMX: S.optional(EmailMxplanDomainExpectedMXList),
+    isAliasDomain: S.optional(S.Boolean),
+    mxIsValid: S.optional(S.Boolean),
+    mxRecord: S.optional(EmailMxplanDomainMxRecordList),
+    mxRelay: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+    srvIsValid: S.optional(S.Boolean),
+    srvRecord: S.optional(EmailMxplanDomainSrvRecordList),
+    state: S.optional(EmailProObjectStateEnum),
+    taskPendingId: S.optional(S.Number),
+    type: S.optional(EmailProDomainTypeEnum),
+  }),
+).annotate({
+  identifier: "EmailMxplanDomain",
+}) as any as S.Schema<EmailMxplanDomain>;
+
+export interface GetEmailMxplanDomainDisclaimerRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const GetEmailMxplanDomainDisclaimerRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/domain/{domainName}/disclaimer",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetEmailMxplanDomainDisclaimerRequest",
+}) as any as S.Schema<GetEmailMxplanDomainDisclaimerRequest>;
+
+/** disclaimer */
+export interface EmailProDisclaimer {
+  /** 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 EmailProDisclaimer = /*@__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: "EmailProDisclaimer",
+}) as any as S.Schema<EmailProDisclaimer>;
+
+export interface GetEmailMxplanExternalContactRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Contact email */
+  externalEmailAddress: string;
+}
+export const GetEmailMxplanExternalContactRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      externalEmailAddress: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/externalContact/{externalEmailAddress}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetEmailMxplanExternalContactRequest",
+}) as any as S.Schema<GetEmailMxplanExternalContactRequest>;
+
+/** External contact for this mxplan service */
+export interface EmailMxplanExternalContact {
+  /** 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 EmailMxplanExternalContact = /*@__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: "EmailMxplanExternalContact",
+}) as any as S.Schema<EmailMxplanExternalContact>;
+
+export interface GetEmailMxplanServerRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+}
+export const GetEmailMxplanServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/mxplan/{service}/server", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanServerRequest",
+}) as any as S.Schema<GetEmailMxplanServerRequest>;
+
+/** Server State */
+export type EmailProServerStateEnum =
+  | "configurationPending"
+  | "notConfigured"
+  | "ok";
+export const EmailProServerStateEnum = /*@__PURE__*/ S.String;
+
+/** Server */
+export interface EmailMxplanServer {
+  /** 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?: number | null;
+}
+export const EmailMxplanServer = /*@__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.Number)),
+  }),
+).annotate({
+  identifier: "EmailMxplanServer",
+}) as any as S.Schema<EmailMxplanServer>;
+
+export interface GetEmailMxplanTaskRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Task id */
+  id: number;
+}
+export const GetEmailMxplanTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/mxplan/{service}/task/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEmailMxplanTaskRequest",
+}) as any as S.Schema<GetEmailMxplanTaskRequest>;
+
+/** 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 ListEmailMxplanRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListEmailMxplanRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListEmailMxplanRequestIamTagsValueList>;
+
+export type ListEmailMxplanRequestIamTagsMap = {
+  [key: string]: ListEmailMxplanRequestIamTagsValueList | undefined;
+};
+export const ListEmailMxplanRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListEmailMxplanRequestIamTagsValueList,
+) as any as S.Schema<ListEmailMxplanRequestIamTagsMap>;
+
+export interface ListEmailMxplanRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListEmailMxplanRequestIamTagsMap;
+}
+export const ListEmailMxplanRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListEmailMxplanRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/email/mxplan", code: 200 })),
+).annotate({
+  identifier: "ListEmailMxplanRequest",
+}) as any as S.Schema<ListEmailMxplanRequest>;
+
+export type ListEmailMxplanResponseBodyList = Array<string>;
+export const ListEmailMxplanResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailMxplanResponseBodyList>;
+
+export type ListEmailMxplanResponse = ListEmailMxplanResponseBodyList;
+export const ListEmailMxplanResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailMxplanResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanResponse",
+}) as any as S.Schema<ListEmailMxplanResponse>;
+
+export interface ListEmailMxplanAccountRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Filter the value of id property (like) */
+  id?: number;
+  /** Filter the value of primaryEmailAddress property (like) */
+  primaryEmailAddress?: string;
+}
+export const ListEmailMxplanAccountRequest = /*@__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/mxplan/{service}/account",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailMxplanAccountRequest",
+}) as any as S.Schema<ListEmailMxplanAccountRequest>;
+
+export type ListEmailMxplanAccountResponseBodyList = Array<string>;
+export const ListEmailMxplanAccountResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailMxplanAccountResponseBodyList>;
+
+export type ListEmailMxplanAccountResponse =
+  ListEmailMxplanAccountResponseBodyList;
+export const ListEmailMxplanAccountResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailMxplanAccountResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanAccountResponse",
+}) as any as S.Schema<ListEmailMxplanAccountResponse>;
+
+export interface ListEmailMxplanAccountAliasRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const ListEmailMxplanAccountAliasRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/mxplan/{service}/account/{email}/alias",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailMxplanAccountAliasRequest",
+}) as any as S.Schema<ListEmailMxplanAccountAliasRequest>;
+
+export type ListEmailMxplanAccountAliasResponseBodyList = Array<string>;
+export const ListEmailMxplanAccountAliasResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListEmailMxplanAccountAliasResponseBodyList>;
+
+export type ListEmailMxplanAccountAliasResponse =
+  ListEmailMxplanAccountAliasResponseBodyList;
+export const ListEmailMxplanAccountAliasResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailMxplanAccountAliasResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanAccountAliasResponse",
+}) as any as S.Schema<ListEmailMxplanAccountAliasResponse>;
+
+export interface ListEmailMxplanAccountCapabilitiesRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const ListEmailMxplanAccountCapabilitiesRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/account/{email}/capabilities",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListEmailMxplanAccountCapabilitiesRequest",
+  }) as any as S.Schema<ListEmailMxplanAccountCapabilitiesRequest>;
+
+/** List of allowed quotas (no constraint if null) */
+export type EmailMxplanAccountCapabilitiesQuotasList = Array<number>;
+export const EmailMxplanAccountCapabilitiesQuotasList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<EmailMxplanAccountCapabilitiesQuotasList>;
+
+/** Account capabilities */
+export interface EmailMxplanAccountCapabilities {
+  /** List of allowed quotas (no constraint if null) */
+  quotas?: EmailMxplanAccountCapabilitiesQuotasList | null;
+}
+export const EmailMxplanAccountCapabilities = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotas: S.optional(S.NullOr(EmailMxplanAccountCapabilitiesQuotasList)),
+  }),
+).annotate({
+  identifier: "EmailMxplanAccountCapabilities",
+}) as any as S.Schema<EmailMxplanAccountCapabilities>;
+
+export interface ListEmailMxplanAccountFullAccessRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const ListEmailMxplanAccountFullAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/account/{email}/fullAccess",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListEmailMxplanAccountFullAccessRequest",
+}) as any as S.Schema<ListEmailMxplanAccountFullAccessRequest>;
+
+export type ListEmailMxplanAccountFullAccessResponseBodyList = Array<number>;
+export const ListEmailMxplanAccountFullAccessResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListEmailMxplanAccountFullAccessResponseBodyList>;
+
+export type ListEmailMxplanAccountFullAccessResponse =
+  ListEmailMxplanAccountFullAccessResponseBodyList;
+export const ListEmailMxplanAccountFullAccessResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListEmailMxplanAccountFullAccessResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanAccountFullAccessResponse",
+}) as any as S.Schema<ListEmailMxplanAccountFullAccessResponse>;
+
+export interface ListEmailMxplanAccountSendAsRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const ListEmailMxplanAccountSendAsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/mxplan/{service}/account/{email}/sendAs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailMxplanAccountSendAsRequest",
+}) as any as S.Schema<ListEmailMxplanAccountSendAsRequest>;
+
+export type ListEmailMxplanAccountSendAsResponseBodyList = Array<number>;
+export const ListEmailMxplanAccountSendAsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListEmailMxplanAccountSendAsResponseBodyList>;
+
+export type ListEmailMxplanAccountSendAsResponse =
+  ListEmailMxplanAccountSendAsResponseBodyList;
+export const ListEmailMxplanAccountSendAsResponse = /*@__PURE__*/ S.suspend(
+  () => ListEmailMxplanAccountSendAsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanAccountSendAsResponse",
+}) as any as S.Schema<ListEmailMxplanAccountSendAsResponse>;
+
+export interface ListEmailMxplanAccountSendOnBehalfToRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const ListEmailMxplanAccountSendOnBehalfToRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      email: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/account/{email}/sendOnBehalfTo",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListEmailMxplanAccountSendOnBehalfToRequest",
+  }) as any as S.Schema<ListEmailMxplanAccountSendOnBehalfToRequest>;
+
+export type ListEmailMxplanAccountSendOnBehalfToResponseBodyList =
+  Array<number>;
+export const ListEmailMxplanAccountSendOnBehalfToResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListEmailMxplanAccountSendOnBehalfToResponseBodyList>;
+
+export type ListEmailMxplanAccountSendOnBehalfToResponse =
+  ListEmailMxplanAccountSendOnBehalfToResponseBodyList;
+export const ListEmailMxplanAccountSendOnBehalfToResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListEmailMxplanAccountSendOnBehalfToResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListEmailMxplanAccountSendOnBehalfToResponse",
+  }) as any as S.Schema<ListEmailMxplanAccountSendOnBehalfToResponse>;
+
+export interface ListEmailMxplanAccountTaskRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+}
+export const ListEmailMxplanAccountTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+    email: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/email/mxplan/{service}/account/{email}/task",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListEmailMxplanAccountTaskRequest",
+}) as any as S.Schema<ListEmailMxplanAccountTaskRequest>;
+
+export type ListEmailMxplanAccountTaskResponseBodyList = Array<number>;
+export const ListEmailMxplanAccountTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListEmailMxplanAccountTaskResponseBodyList>;
+
+export type ListEmailMxplanAccountTaskResponse =
+  ListEmailMxplanAccountTaskResponseBodyList;
+export const ListEmailMxplanAccountTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailMxplanAccountTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanAccountTaskResponse",
+}) as any as S.Schema<ListEmailMxplanAccountTaskResponse>;
+
+export interface ListEmailMxplanDomainRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Filter the value of state property (=) */
+  state?: EmailProObjectStateEnum | (string & {});
+}
+export const ListEmailMxplanDomainRequest = /*@__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/mxplan/{service}/domain", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListEmailMxplanDomainRequest",
+}) as any as S.Schema<ListEmailMxplanDomainRequest>;
+
+export type ListEmailMxplanDomainResponseBodyList = Array<string>;
+export const ListEmailMxplanDomainResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListEmailMxplanDomainResponseBodyList>;
+
+export type ListEmailMxplanDomainResponse =
+  ListEmailMxplanDomainResponseBodyList;
+export const ListEmailMxplanDomainResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailMxplanDomainResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanDomainResponse",
+}) as any as S.Schema<ListEmailMxplanDomainResponse>;
+
+export interface ListEmailMxplanDomainDisclaimerAttributeRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Domain name */
+  domainName: string;
+}
+export const ListEmailMxplanDomainDisclaimerAttributeRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+      domainName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/email/mxplan/{service}/domain/{domainName}/disclaimerAttribute",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListEmailMxplanDomainDisclaimerAttributeRequest",
+  }) as any as S.Schema<ListEmailMxplanDomainDisclaimerAttributeRequest>;
+
+/** 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 ListEmailMxplanDomainDisclaimerAttributeResponseBodyList =
+  Array<EmailProDisclaimerAttributeEnum>;
+export const ListEmailMxplanDomainDisclaimerAttributeResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    EmailProDisclaimerAttributeEnum,
+  ) as any as S.Schema<ListEmailMxplanDomainDisclaimerAttributeResponseBodyList>;
+
+export type ListEmailMxplanDomainDisclaimerAttributeResponse =
+  ListEmailMxplanDomainDisclaimerAttributeResponseBodyList;
+export const ListEmailMxplanDomainDisclaimerAttributeResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListEmailMxplanDomainDisclaimerAttributeResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListEmailMxplanDomainDisclaimerAttributeResponse",
+  }) as any as S.Schema<ListEmailMxplanDomainDisclaimerAttributeResponse>;
+
+export interface ListEmailMxplanExternalContactRequest {
+  /** The internal name of your mxplan organization */
+  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 ListEmailMxplanExternalContactRequest = /*@__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/mxplan/{service}/externalContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListEmailMxplanExternalContactRequest",
+}) as any as S.Schema<ListEmailMxplanExternalContactRequest>;
+
+export type ListEmailMxplanExternalContactResponseBodyList = Array<string>;
+export const ListEmailMxplanExternalContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListEmailMxplanExternalContactResponseBodyList>;
+
+export type ListEmailMxplanExternalContactResponse =
+  ListEmailMxplanExternalContactResponseBodyList;
+export const ListEmailMxplanExternalContactResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListEmailMxplanExternalContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanExternalContactResponse",
+}) as any as S.Schema<ListEmailMxplanExternalContactResponse>;
+
+export interface ListEmailMxplanTaskRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+}
+export const ListEmailMxplanTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/email/mxplan/{service}/task", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListEmailMxplanTaskRequest",
+}) as any as S.Schema<ListEmailMxplanTaskRequest>;
+
+export type ListEmailMxplanTaskResponseBodyList = Array<number>;
+export const ListEmailMxplanTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListEmailMxplanTaskResponseBodyList>;
+
+export type ListEmailMxplanTaskResponse = ListEmailMxplanTaskResponseBodyList;
+export const ListEmailMxplanTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListEmailMxplanTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListEmailMxplanTaskResponse",
+}) as any as S.Schema<ListEmailMxplanTaskResponse>;
+
+export interface PutEmailMxplanRequest {
+  /** The internal name of your mxplan 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?: EmailProSpamAndVirusConfiguration;
+}
+export const PutEmailMxplanRequest = /*@__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(EmailProSpamAndVirusConfiguration),
+  }).pipe(T.Http({ method: "PUT", uri: "/email/mxplan/{service}", code: 200 })),
+).annotate({
+  identifier: "PutEmailMxplanRequest",
+}) as any as S.Schema<PutEmailMxplanRequest>;
+
+export interface PutEmailMxplanResponse {}
+export const PutEmailMxplanResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailMxplanResponse",
+}) as any as S.Schema<PutEmailMxplanResponse>;
+
+/** Enable or disable anti-virus and anti-spam */
+export type PutEmailMxplanAccountRequestMailingFilterList = Array<
+  EmailProMailingFilterEnum | (string & {})
+>;
+export const PutEmailMxplanAccountRequestMailingFilterList =
+  /*@__PURE__*/ S.Array(
+    EmailProMailingFilterEnum,
+  ) as any as S.Schema<PutEmailMxplanAccountRequestMailingFilterList>;
+
+export interface PutEmailMxplanAccountRequest {
+  /** The internal name of your mxplan 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?: PutEmailMxplanAccountRequestMailingFilterList | null;
+  /** Account maximum size */
+  quota?: number;
+  /** change the renew period */
+  renewPeriod?: EmailProRenewPeriodEnum | (string & {}) | null;
+  /** Spam and Antivirus configuration */
+  spamAndVirusConfiguration?: EmailProSpamAndVirusConfiguration;
+}
+export const PutEmailMxplanAccountRequest = /*@__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(PutEmailMxplanAccountRequestMailingFilterList),
+    ),
+    quota: S.optional(S.Number),
+    renewPeriod: S.optional(S.NullOr(EmailProRenewPeriodEnum)),
+    spamAndVirusConfiguration: S.optional(EmailProSpamAndVirusConfiguration),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/email/mxplan/{service}/account/{email}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailMxplanAccountRequest",
+}) as any as S.Schema<PutEmailMxplanAccountRequest>;
+
+export interface PutEmailMxplanAccountResponse {}
+export const PutEmailMxplanAccountResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailMxplanAccountResponse",
+}) as any as S.Schema<PutEmailMxplanAccountResponse>;
+
+export interface PutEmailMxplanDomainRequest {
+  /** The internal name of your mxplan 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 PutEmailMxplanDomainRequest = /*@__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/mxplan/{service}/domain/{domainName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutEmailMxplanDomainRequest",
+}) as any as S.Schema<PutEmailMxplanDomainRequest>;
+
+export interface PutEmailMxplanDomainResponse {}
+export const PutEmailMxplanDomainResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutEmailMxplanDomainResponse",
+}) as any as S.Schema<PutEmailMxplanDomainResponse>;
+
+export interface PutEmailMxplanDomainDisclaimerRequest {
+  /** The internal name of your mxplan 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 PutEmailMxplanDomainDisclaimerRequest = /*@__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/mxplan/{service}/domain/{domainName}/disclaimer",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "PutEmailMxplanDomainDisclaimerRequest",
+}) as any as S.Schema<PutEmailMxplanDomainDisclaimerRequest>;
+
+export interface PutEmailMxplanDomainDisclaimerResponse {}
+export const PutEmailMxplanDomainDisclaimerResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "PutEmailMxplanDomainDisclaimerResponse",
+}) as any as S.Schema<PutEmailMxplanDomainDisclaimerResponse>;
+
+export interface PutEmailMxplanExternalContactRequest {
+  /** The internal name of your mxplan 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 PutEmailMxplanExternalContactRequest = /*@__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/mxplan/{service}/externalContact/{externalEmailAddress}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "PutEmailMxplanExternalContactRequest",
+}) as any as S.Schema<PutEmailMxplanExternalContactRequest>;
+
+export interface PutEmailMxplanExternalContactResponse {}
+export const PutEmailMxplanExternalContactResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "PutEmailMxplanExternalContactResponse",
+}) as any as S.Schema<PutEmailMxplanExternalContactResponse>;
+
+export interface SendEmailMxplanAccountAsRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+  /** Default email for this mailbox */
+  email: string;
+  /** Account id to allow to send mails from this mailbox */
+  allowAccountId: number;
+}
+export const SendEmailMxplanAccountAsRequest = /*@__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/mxplan/{service}/account/{email}/sendAs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SendEmailMxplanAccountAsRequest",
+}) as any as S.Schema<SendEmailMxplanAccountAsRequest>;
+
+export interface SendEmailMxplanAccountOnBehalfToRequest {
+  /** The internal name of your mxplan 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 SendEmailMxplanAccountOnBehalfToRequest = /*@__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/mxplan/{service}/account/{email}/sendOnBehalfTo",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "SendEmailMxplanAccountOnBehalfToRequest",
+}) as any as S.Schema<SendEmailMxplanAccountOnBehalfToRequest>;
+
+export interface UpdateEmailMxplanFlagsOnAllAccountsRequest {
+  /** The internal name of your mxplan organization */
+  service: string;
+}
+export const UpdateEmailMxplanFlagsOnAllAccountsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/email/mxplan/{service}/updateFlagsOnAllAccounts",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "UpdateEmailMxplanFlagsOnAllAccountsRequest",
+  }) as any as S.Schema<UpdateEmailMxplanFlagsOnAllAccountsRequest>;
+
+export interface UpdateEmailMxplanFlagsOnAllAccountsResponse {}
+export const UpdateEmailMxplanFlagsOnAllAccountsResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "UpdateEmailMxplanFlagsOnAllAccountsResponse",
+  }) as any as S.Schema<UpdateEmailMxplanFlagsOnAllAccountsResponse>;
+
+export type CreateEmailMxplanAccountAliasError = OvhOpError;
+/** Create new alias */
+export const createEmailMxplanAccountAlias: API.OperationMethod<
+  CreateEmailMxplanAccountAliasRequest,
+  EmailProTask,
+  CreateEmailMxplanAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailMxplanAccountAliasRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailMxplanAccountChangePasswordError = OvhOpError;
+/** Change mailbox password */
+export const createEmailMxplanAccountChangePassword: API.OperationMethod<
+  CreateEmailMxplanAccountChangePasswordRequest,
+  EmailProTask,
+  CreateEmailMxplanAccountChangePasswordError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailMxplanAccountChangePasswordRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailMxplanAccountDiagnosticError = OvhOpError;
+/** Create new diagnosis request */
+export const createEmailMxplanAccountDiagnostic: API.OperationMethod<
+  CreateEmailMxplanAccountDiagnosticRequest,
+  EmailProTask,
+  CreateEmailMxplanAccountDiagnosticError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailMxplanAccountDiagnosticRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailMxplanAccountFullAccessError = OvhOpError;
+/** Allow full access to a user */
+export const createEmailMxplanAccountFullAccess: API.OperationMethod<
+  CreateEmailMxplanAccountFullAccessRequest,
+  EmailProTask,
+  CreateEmailMxplanAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailMxplanAccountFullAccessRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailMxplanDomainDisclaimerError = OvhOpError;
+/** Create organization disclaimer of each email */
+export const createEmailMxplanDomainDisclaimer: API.OperationMethod<
+  CreateEmailMxplanDomainDisclaimerRequest,
+  EmailProTask,
+  CreateEmailMxplanDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailMxplanDomainDisclaimerRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateEmailMxplanExternalContactError = OvhOpError;
+/** create new external contact */
+export const createEmailMxplanExternalContact: API.OperationMethod<
+  CreateEmailMxplanExternalContactRequest,
+  EmailProTask,
+  CreateEmailMxplanExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEmailMxplanExternalContactRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanAccountError = OvhOpError;
+/** Delete existing mailbox in mxplan server */
+export const deleteEmailMxplanAccount: API.OperationMethod<
+  DeleteEmailMxplanAccountRequest,
+  EmailProTask,
+  DeleteEmailMxplanAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanAccountRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanAccountAliasError = OvhOpError;
+/** Delete existing alias */
+export const deleteEmailMxplanAccountAlias: API.OperationMethod<
+  DeleteEmailMxplanAccountAliasRequest,
+  EmailProTask,
+  DeleteEmailMxplanAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanAccountAliasRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanAccountFullAccessError = OvhOpError;
+/** Revoke full access */
+export const deleteEmailMxplanAccountFullAccess: API.OperationMethod<
+  DeleteEmailMxplanAccountFullAccessRequest,
+  EmailProTask,
+  DeleteEmailMxplanAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanAccountFullAccessRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanAccountSendAsError = OvhOpError;
+/** Delete allowed user for sendAs */
+export const deleteEmailMxplanAccountSendAs: API.OperationMethod<
+  DeleteEmailMxplanAccountSendAsRequest,
+  EmailProTask,
+  DeleteEmailMxplanAccountSendAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanAccountSendAsRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanAccountSendOnBehalfToError = OvhOpError;
+/** Delete allowed user for SendOnBehalfTo */
+export const deleteEmailMxplanAccountSendOnBehalfTo: API.OperationMethod<
+  DeleteEmailMxplanAccountSendOnBehalfToRequest,
+  EmailProTask,
+  DeleteEmailMxplanAccountSendOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanAccountSendOnBehalfToRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanDomainDisclaimerError = OvhOpError;
+/** Delete existing organization disclaimer */
+export const deleteEmailMxplanDomainDisclaimer: API.OperationMethod<
+  DeleteEmailMxplanDomainDisclaimerRequest,
+  EmailProTask,
+  DeleteEmailMxplanDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanDomainDisclaimerRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEmailMxplanExternalContactError = OvhOpError;
+/** delete external contact */
+export const deleteEmailMxplanExternalContact: API.OperationMethod<
+  DeleteEmailMxplanExternalContactRequest,
+  EmailProTask,
+  DeleteEmailMxplanExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEmailMxplanExternalContactRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplan: API.OperationMethod<
+  GetEmailMxplanRequest,
+  EmailMxplanServiceWithIAM,
+  GetEmailMxplanError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanRequest,
+  output: EmailMxplanServiceWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccount: API.OperationMethod<
+  GetEmailMxplanAccountRequest,
+  EmailMxplanAccount,
+  GetEmailMxplanAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountRequest,
+  output: EmailMxplanAccount,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountAliasError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccountAlias: API.OperationMethod<
+  GetEmailMxplanAccountAliasRequest,
+  EmailMxplanAccountAlias,
+  GetEmailMxplanAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountAliasRequest,
+  output: EmailMxplanAccountAlias,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountDiagnosticError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccountDiagnostic: API.OperationMethod<
+  GetEmailMxplanAccountDiagnosticRequest,
+  EmailMxplanAccountDiagnosis,
+  GetEmailMxplanAccountDiagnosticError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountDiagnosticRequest,
+  output: EmailMxplanAccountDiagnosis,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountFullAccessError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccountFullAccess: API.OperationMethod<
+  GetEmailMxplanAccountFullAccessRequest,
+  EmailMxplanAccountFullAccess,
+  GetEmailMxplanAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountFullAccessRequest,
+  output: EmailMxplanAccountFullAccess,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountSendAsError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccountSendAs: API.OperationMethod<
+  GetEmailMxplanAccountSendAsRequest,
+  EmailMxplanAccountSendAs,
+  GetEmailMxplanAccountSendAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountSendAsRequest,
+  output: EmailMxplanAccountSendAs,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountSendOnBehalfToError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccountSendOnBehalfTo: API.OperationMethod<
+  GetEmailMxplanAccountSendOnBehalfToRequest,
+  EmailMxplanAccountSendOnBehalfTo,
+  GetEmailMxplanAccountSendOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountSendOnBehalfToRequest,
+  output: EmailMxplanAccountSendOnBehalfTo,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanAccountTaskError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanAccountTask: API.OperationMethod<
+  GetEmailMxplanAccountTaskRequest,
+  EmailProTask,
+  GetEmailMxplanAccountTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanAccountTaskRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanDomainError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanDomain: API.OperationMethod<
+  GetEmailMxplanDomainRequest,
+  EmailMxplanDomain,
+  GetEmailMxplanDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanDomainRequest,
+  output: EmailMxplanDomain,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanDomainDisclaimerError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanDomainDisclaimer: API.OperationMethod<
+  GetEmailMxplanDomainDisclaimerRequest,
+  EmailProDisclaimer,
+  GetEmailMxplanDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanDomainDisclaimerRequest,
+  output: EmailProDisclaimer,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanExternalContactError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanExternalContact: API.OperationMethod<
+  GetEmailMxplanExternalContactRequest,
+  EmailMxplanExternalContact,
+  GetEmailMxplanExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanExternalContactRequest,
+  output: EmailMxplanExternalContact,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanServerError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanServer: API.OperationMethod<
+  GetEmailMxplanServerRequest,
+  EmailMxplanServer,
+  GetEmailMxplanServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanServerRequest,
+  output: EmailMxplanServer,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEmailMxplanTaskError = OvhOpError;
+/** Get this object properties */
+export const getEmailMxplanTask: API.OperationMethod<
+  GetEmailMxplanTaskRequest,
+  EmailProTask,
+  GetEmailMxplanTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEmailMxplanTaskRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanError = OvhOpError;
+/** List available services */
+export const listEmailMxplan: API.OperationMethod<
+  ListEmailMxplanRequest,
+  ListEmailMxplanResponse,
+  ListEmailMxplanError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanRequest,
+  output: ListEmailMxplanResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountError = OvhOpError;
+/** Accounts associated to this mxplan service */
+export const listEmailMxplanAccount: API.OperationMethod<
+  ListEmailMxplanAccountRequest,
+  ListEmailMxplanAccountResponse,
+  ListEmailMxplanAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountRequest,
+  output: ListEmailMxplanAccountResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountAliasError = OvhOpError;
+/** Aliases associated to this mailbox */
+export const listEmailMxplanAccountAlias: API.OperationMethod<
+  ListEmailMxplanAccountAliasRequest,
+  ListEmailMxplanAccountAliasResponse,
+  ListEmailMxplanAccountAliasError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountAliasRequest,
+  output: ListEmailMxplanAccountAliasResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountCapabilitiesError = OvhOpError;
+/** Get available capabilities for this account */
+export const listEmailMxplanAccountCapabilities: API.OperationMethod<
+  ListEmailMxplanAccountCapabilitiesRequest,
+  EmailMxplanAccountCapabilities,
+  ListEmailMxplanAccountCapabilitiesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountCapabilitiesRequest,
+  output: EmailMxplanAccountCapabilities,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountFullAccessError = OvhOpError;
+/** Full access granted users for this mailbox */
+export const listEmailMxplanAccountFullAccess: API.OperationMethod<
+  ListEmailMxplanAccountFullAccessRequest,
+  ListEmailMxplanAccountFullAccessResponse,
+  ListEmailMxplanAccountFullAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountFullAccessRequest,
+  output: ListEmailMxplanAccountFullAccessResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountSendAsError = OvhOpError;
+/** Send as granted users for this mailbox */
+export const listEmailMxplanAccountSendAs: API.OperationMethod<
+  ListEmailMxplanAccountSendAsRequest,
+  ListEmailMxplanAccountSendAsResponse,
+  ListEmailMxplanAccountSendAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountSendAsRequest,
+  output: ListEmailMxplanAccountSendAsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountSendOnBehalfToError = OvhOpError;
+/** SendOnBehalfTo granted users for this mailbox */
+export const listEmailMxplanAccountSendOnBehalfTo: API.OperationMethod<
+  ListEmailMxplanAccountSendOnBehalfToRequest,
+  ListEmailMxplanAccountSendOnBehalfToResponse,
+  ListEmailMxplanAccountSendOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountSendOnBehalfToRequest,
+  output: ListEmailMxplanAccountSendOnBehalfToResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanAccountTaskError = OvhOpError;
+/** Pending task for this mailbox */
+export const listEmailMxplanAccountTask: API.OperationMethod<
+  ListEmailMxplanAccountTaskRequest,
+  ListEmailMxplanAccountTaskResponse,
+  ListEmailMxplanAccountTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanAccountTaskRequest,
+  output: ListEmailMxplanAccountTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanDomainError = OvhOpError;
+/** Domains associated to this service */
+export const listEmailMxplanDomain: API.OperationMethod<
+  ListEmailMxplanDomainRequest,
+  ListEmailMxplanDomainResponse,
+  ListEmailMxplanDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanDomainRequest,
+  output: ListEmailMxplanDomainResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanDomainDisclaimerAttributeError = OvhOpError;
+/** Get diclaimer attributes to substitute with Active Directory properties */
+export const listEmailMxplanDomainDisclaimerAttribute: API.OperationMethod<
+  ListEmailMxplanDomainDisclaimerAttributeRequest,
+  ListEmailMxplanDomainDisclaimerAttributeResponse,
+  ListEmailMxplanDomainDisclaimerAttributeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanDomainDisclaimerAttributeRequest,
+  output: ListEmailMxplanDomainDisclaimerAttributeResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanExternalContactError = OvhOpError;
+/** External contacts for this service */
+export const listEmailMxplanExternalContact: API.OperationMethod<
+  ListEmailMxplanExternalContactRequest,
+  ListEmailMxplanExternalContactResponse,
+  ListEmailMxplanExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanExternalContactRequest,
+  output: ListEmailMxplanExternalContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListEmailMxplanTaskError = OvhOpError;
+/** Pending actions */
+export const listEmailMxplanTask: API.OperationMethod<
+  ListEmailMxplanTaskRequest,
+  ListEmailMxplanTaskResponse,
+  ListEmailMxplanTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListEmailMxplanTaskRequest,
+  output: ListEmailMxplanTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailMxplanError = OvhOpError;
+/** Alter this object properties */
+export const putEmailMxplan: API.OperationMethod<
+  PutEmailMxplanRequest,
+  PutEmailMxplanResponse,
+  PutEmailMxplanError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailMxplanRequest,
+  output: PutEmailMxplanResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailMxplanAccountError = OvhOpError;
+/** Alter this object properties */
+export const putEmailMxplanAccount: API.OperationMethod<
+  PutEmailMxplanAccountRequest,
+  PutEmailMxplanAccountResponse,
+  PutEmailMxplanAccountError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailMxplanAccountRequest,
+  output: PutEmailMxplanAccountResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailMxplanDomainError = OvhOpError;
+/** Alter this object properties */
+export const putEmailMxplanDomain: API.OperationMethod<
+  PutEmailMxplanDomainRequest,
+  PutEmailMxplanDomainResponse,
+  PutEmailMxplanDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailMxplanDomainRequest,
+  output: PutEmailMxplanDomainResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailMxplanDomainDisclaimerError = OvhOpError;
+/** Alter this object properties */
+export const putEmailMxplanDomainDisclaimer: API.OperationMethod<
+  PutEmailMxplanDomainDisclaimerRequest,
+  PutEmailMxplanDomainDisclaimerResponse,
+  PutEmailMxplanDomainDisclaimerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailMxplanDomainDisclaimerRequest,
+  output: PutEmailMxplanDomainDisclaimerResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutEmailMxplanExternalContactError = OvhOpError;
+/** Alter this object properties */
+export const putEmailMxplanExternalContact: API.OperationMethod<
+  PutEmailMxplanExternalContactRequest,
+  PutEmailMxplanExternalContactResponse,
+  PutEmailMxplanExternalContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutEmailMxplanExternalContactRequest,
+  output: PutEmailMxplanExternalContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SendEmailMxplanAccountAsError = OvhOpError;
+/** Allow another user to send mails from this mailbox */
+export const sendEmailMxplanAccountAs: API.OperationMethod<
+  SendEmailMxplanAccountAsRequest,
+  EmailProTask,
+  SendEmailMxplanAccountAsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SendEmailMxplanAccountAsRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SendEmailMxplanAccountOnBehalfToError = OvhOpError;
+/** Allow another user to Send On Behalf To mails from this mailbox */
+export const sendEmailMxplanAccountOnBehalfTo: API.OperationMethod<
+  SendEmailMxplanAccountOnBehalfToRequest,
+  EmailProTask,
+  SendEmailMxplanAccountOnBehalfToError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SendEmailMxplanAccountOnBehalfToRequest,
+  output: EmailProTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateEmailMxplanFlagsOnAllAccountsError = OvhOpError;
+/** Update spam and virus flags on all active accounts */
+export const updateEmailMxplanFlagsOnAllAccounts: API.OperationMethod<
+  UpdateEmailMxplanFlagsOnAllAccountsRequest,
+  UpdateEmailMxplanFlagsOnAllAccountsResponse,
+  UpdateEmailMxplanFlagsOnAllAccountsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateEmailMxplanFlagsOnAllAccountsRequest,
+  output: UpdateEmailMxplanFlagsOnAllAccountsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));