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

package/src/services/sslgateway.ts

@@ -0,0 +1,1408 @@
+// 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 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 };
+
+/** All future uses you can provide for a service termination */
+export type ServiceTerminationFutureUseEnum =
+  | "NOT_REPLACING_SERVICE"
+  | "OTHER"
+  | "SUBSCRIBE_AN_OTHER_SERVICE"
+  | "SUBSCRIBE_OTHER_KIND_OF_SERVICE_WITH_COMPETITOR"
+  | "SUBSCRIBE_SIMILAR_SERVICE_WITH_COMPETITOR";
+export const ServiceTerminationFutureUseEnum = /*@__PURE__*/ S.String;
+
+/** All reasons you can provide for a service termination */
+export type ServiceTerminationReasonEnum =
+  | "FEATURES_DONT_SUIT_ME"
+  | "LACK_OF_PERFORMANCES"
+  | "MIGRATED_TO_ANOTHER_OVH_PRODUCT"
+  | "MIGRATED_TO_COMPETITOR"
+  | "NOT_ENOUGH_RECOGNITION"
+  | "NOT_NEEDED_ANYMORE"
+  | "NOT_RELIABLE"
+  | "NO_ANSWER"
+  | "OTHER"
+  | "PRODUCT_DIMENSION_DONT_SUIT_ME"
+  | "PRODUCT_TOOLS_DONT_SUIT_ME"
+  | "TOO_EXPENSIVE"
+  | "TOO_HARD_TO_USE"
+  | "UNSATIFIED_BY_CUSTOMER_SUPPORT";
+export const ServiceTerminationReasonEnum = /*@__PURE__*/ S.String;
+
+export interface ConfirmSslGatewayTerminationRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Commentary about your termination request */
+  commentary?: string;
+  /** What next after your termination request */
+  futureUse?: ServiceTerminationFutureUseEnum | (string & {});
+  /** Reason of your termination request */
+  reason?: ServiceTerminationReasonEnum | (string & {});
+  /** The termination token sent by email to the admin contact */
+  token: string;
+}
+export const ConfirmSslGatewayTerminationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    commentary: S.optional(S.String),
+    futureUse: S.optional(ServiceTerminationFutureUseEnum),
+    reason: S.optional(ServiceTerminationReasonEnum),
+    token: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sslGateway/{serviceName}/confirmTermination",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ConfirmSslGatewayTerminationRequest",
+}) as any as S.Schema<ConfirmSslGatewayTerminationRequest>;
+
+export type ConfirmSslGatewayTerminationResponse = string;
+export const ConfirmSslGatewayTerminationResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ConfirmSslGatewayTerminationResponse",
+}) as any as S.Schema<ConfirmSslGatewayTerminationResponse>;
+
+export interface CreateSslGatewayChangeContactRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** The contact to set as admin contact */
+  contactAdmin?: string;
+  /** The contact to set as billing contact */
+  contactBilling?: string;
+  /** The contact to set as tech contact */
+  contactTech?: string;
+}
+export const CreateSslGatewayChangeContactRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      contactAdmin: S.optional(S.String),
+      contactBilling: S.optional(S.String),
+      contactTech: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sslGateway/{serviceName}/changeContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateSslGatewayChangeContactRequest",
+}) as any as S.Schema<CreateSslGatewayChangeContactRequest>;
+
+export type CreateSslGatewayChangeContactResponseBodyList = Array<number>;
+export const CreateSslGatewayChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateSslGatewayChangeContactResponseBodyList>;
+
+export type CreateSslGatewayChangeContactResponse =
+  CreateSslGatewayChangeContactResponseBodyList;
+export const CreateSslGatewayChangeContactResponse = /*@__PURE__*/ S.suspend(
+  () => CreateSslGatewayChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateSslGatewayChangeContactResponse",
+}) as any as S.Schema<CreateSslGatewayChangeContactResponse>;
+
+export interface CreateSslGatewayDomainRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Domain to attach */
+  domain: string;
+}
+export const CreateSslGatewayDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    domain: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sslGateway/{serviceName}/domain",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateSslGatewayDomainRequest",
+}) as any as S.Schema<CreateSslGatewayDomainRequest>;
+
+/** Possible values for SSL Gateway domain state */
+export type SslGatewayDomainStateEnum =
+  | "creating"
+  | "deleted"
+  | "deleting"
+  | "http-only"
+  | "internal"
+  | "ok";
+export const SslGatewayDomainStateEnum = /*@__PURE__*/ S.String;
+
+/** Domain attached to an SSL Gateway */
+export interface SslGatewayDomain {
+  /** Domain name attached to your SSL Gateway */
+  domain?: string;
+  /** Id of your domain */
+  id?: number;
+  /** Domain state */
+  state?: SslGatewayDomainStateEnum;
+}
+export const SslGatewayDomain = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    domain: S.optional(S.String),
+    id: S.optional(S.Number),
+    state: S.optional(SslGatewayDomainStateEnum),
+  }),
+).annotate({
+  identifier: "SslGatewayDomain",
+}) as any as S.Schema<SslGatewayDomain>;
+
+export interface CreateSslGatewayServerRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** IPv4 address of your server */
+  address: string;
+  /** Port of your server */
+  port: number;
+}
+export const CreateSslGatewayServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    address: S.String,
+    port: S.Number,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sslGateway/{serviceName}/server",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateSslGatewayServerRequest",
+}) as any as S.Schema<CreateSslGatewayServerRequest>;
+
+/** Possible values for SSL Gateway server state */
+export type SslGatewayServerStateEnum =
+  | "creating"
+  | "deleted"
+  | "deleting"
+  | "internal"
+  | "ok"
+  | "updating";
+export const SslGatewayServerStateEnum = /*@__PURE__*/ S.String;
+
+/** Server attached to an SSL Gateway */
+export interface SslGatewayServer {
+  /** IP address of the server attached to your SSL Gateway */
+  address?: string;
+  /** Id of your server */
+  id?: number;
+  /** Port of your server attached to your SSL Gateway */
+  port?: number;
+  /** Server state */
+  state?: SslGatewayServerStateEnum;
+}
+export const SslGatewayServer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    address: S.optional(S.String),
+    id: S.optional(S.Number),
+    port: S.optional(S.Number),
+    state: S.optional(SslGatewayServerStateEnum),
+  }),
+).annotate({
+  identifier: "SslGatewayServer",
+}) as any as S.Schema<SslGatewayServer>;
+
+export interface DeleteSslGatewayDomainRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Id of your domain */
+  id: number;
+}
+export const DeleteSslGatewayDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/sslGateway/{serviceName}/domain/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteSslGatewayDomainRequest",
+}) as any as S.Schema<DeleteSslGatewayDomainRequest>;
+
+export interface DeleteSslGatewayDomainResponse {}
+export const DeleteSslGatewayDomainResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteSslGatewayDomainResponse",
+}) as any as S.Schema<DeleteSslGatewayDomainResponse>;
+
+export interface DeleteSslGatewayServerRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Id of your server */
+  id: number;
+}
+export const DeleteSslGatewayServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/sslGateway/{serviceName}/server/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteSslGatewayServerRequest",
+}) as any as S.Schema<DeleteSslGatewayServerRequest>;
+
+export interface DeleteSslGatewayServerResponse {}
+export const DeleteSslGatewayServerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteSslGatewayServerResponse",
+}) as any as S.Schema<DeleteSslGatewayServerResponse>;
+
+export interface GetSslGatewayRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const GetSslGatewayRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sslGateway/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSslGatewayRequest",
+}) as any as S.Schema<GetSslGatewayRequest>;
+
+/** Restrict SSL Gateway access to these ip block. No restriction if null */
+export type SslGatewaySslGatewayWithIAMAllowedSourceList = Array<string>;
+export const SslGatewaySslGatewayWithIAMAllowedSourceList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<SslGatewaySslGatewayWithIAMAllowedSourceList>;
+
+/** 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>;
+
+/** List of SSL Gateway offers */
+export type SslGatewayOfferEnum =
+  | "advanced"
+  | "enterprise"
+  | "free"
+  | "internal";
+export const SslGatewayOfferEnum = /*@__PURE__*/ S.String;
+
+/** Possible values for ssl ciphers */
+export type SslGatewaySslConfigurationEnum =
+  | "intermediate"
+  | "internal"
+  | "modern";
+export const SslGatewaySslConfigurationEnum = /*@__PURE__*/ S.String;
+
+/** Possible values for SSL Gateway state */
+export type SslGatewayStateEnum =
+  | "creating"
+  | "deleted"
+  | "deleting"
+  | "http-only"
+  | "internal"
+  | "ok"
+  | "suspended"
+  | "upgrading";
+export const SslGatewayStateEnum = /*@__PURE__*/ S.String;
+
+/** Zones of your SSL Gateway */
+export type SslGatewaySslGatewayWithIAMZonesList = Array<string>;
+export const SslGatewaySslGatewayWithIAMZonesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SslGatewaySslGatewayWithIAMZonesList>;
+
+/** Your SSL Gateway */
+export interface SslGatewaySslGatewayWithIAM {
+  /** Restrict SSL Gateway access to these ip block. No restriction if null */
+  allowedSource?: SslGatewaySslGatewayWithIAMAllowedSourceList | null;
+  /** Custom name of your SSL Gateway */
+  displayName?: string | null;
+  /** Set to true to enable Strict-Transport-Security HTTP header */
+  hsts?: boolean;
+  /** Set to true to enable https redirect */
+  httpsRedirect?: boolean;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** The IPv4 you need to put in the A field of your domain name */
+  ipv4?: string;
+  /** The IPv6 you need to put in the AAAA field of your domain name */
+  ipv6?: string | null;
+  /** The metrics token associated with your SSL Gateway */
+  metricsToken?: string | null;
+  /** Current offer for your SSL Gateway */
+  offer?: SslGatewayOfferEnum;
+  /** Custom reverse for your SSL Gateway */
+  reverse?: string | null;
+  /** Set to true to contact backend servers over HTTPS */
+  serverHttps?: boolean;
+  /** The internal name of your SSL Gateway */
+  serviceName?: string;
+  /** Modern oldest compatible clients : Firefox 27, Chrome 30, IE 11 on Windows 7, Edge, Opera 17, Safari 9, Android 5.0, and Java 8. Intermediate oldest compatible clients : Firefox 1, Chrome 1, IE 7, Opera 5, Safari 1, Windows XP IE8, Android 2.3, Java 7. Intermediate if null. */
+  sslConfiguration?: SslGatewaySslConfigurationEnum | null;
+  /** Current state of your SSL Gateway */
+  state?: SslGatewayStateEnum;
+  /** Zones of your SSL Gateway */
+  zones?: SslGatewaySslGatewayWithIAMZonesList;
+}
+export const SslGatewaySslGatewayWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedSource: S.optional(
+      S.NullOr(SslGatewaySslGatewayWithIAMAllowedSourceList),
+    ),
+    displayName: S.optional(S.NullOr(S.String)),
+    hsts: S.optional(S.Boolean),
+    httpsRedirect: S.optional(S.Boolean),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    ipv4: S.optional(S.String),
+    ipv6: S.optional(S.NullOr(S.String)),
+    metricsToken: S.optional(S.NullOr(S.String)),
+    offer: S.optional(SslGatewayOfferEnum),
+    reverse: S.optional(S.NullOr(S.String)),
+    serverHttps: S.optional(S.Boolean),
+    serviceName: S.optional(S.String),
+    sslConfiguration: S.optional(S.NullOr(SslGatewaySslConfigurationEnum)),
+    state: S.optional(SslGatewayStateEnum),
+    zones: S.optional(SslGatewaySslGatewayWithIAMZonesList),
+  }),
+).annotate({
+  identifier: "SslGatewaySslGatewayWithIAM",
+}) as any as S.Schema<SslGatewaySslGatewayWithIAM>;
+
+export interface GetSslGatewayDomainRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Id of your domain */
+  id: number;
+}
+export const GetSslGatewayDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/domain/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSslGatewayDomainRequest",
+}) as any as S.Schema<GetSslGatewayDomainRequest>;
+
+export interface GetSslGatewayServerRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Id of your server */
+  id: number;
+}
+export const GetSslGatewayServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/server/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSslGatewayServerRequest",
+}) as any as S.Schema<GetSslGatewayServerRequest>;
+
+export interface GetSslGatewayServiceInfosRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const GetSslGatewayServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSslGatewayServiceInfosRequest",
+}) as any as S.Schema<GetSslGatewayServiceInfosRequest>;
+
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export const ServicesServicePossibleRenewPeriodList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ServicesServicePossibleRenewPeriodList>;
+
+/** Map a possible renew for a specific service */
+export interface ServiceRenewType {
+  /** The service is automatically renewed */
+  automatic?: boolean;
+  /** The service will be deleted at expiration */
+  deleteAtExpiration?: boolean;
+  /** The service forced to be renewed */
+  forced?: boolean;
+  /** The service needs to be manually renewed and paid */
+  manualPayment?: boolean | null;
+  /** period of renew in month */
+  period?: number | null;
+}
+export const ServiceRenewType = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    automatic: S.optional(S.Boolean),
+    deleteAtExpiration: S.optional(S.Boolean),
+    forced: S.optional(S.Boolean),
+    manualPayment: S.optional(S.NullOr(S.Boolean)),
+    period: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "ServiceRenewType",
+}) as any as S.Schema<ServiceRenewType>;
+
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum =
+  | "automaticForcedProduct"
+  | "automaticV2012"
+  | "automaticV2014"
+  | "automaticV2016"
+  | "automaticV2024"
+  | "manual"
+  | "oneShot"
+  | "option";
+export const ServiceRenewalTypeEnum = /*@__PURE__*/ S.String;
+
+export type ServiceStateEnum =
+  | "autorenewInProgress"
+  | "expired"
+  | "inCreation"
+  | "ok"
+  | "pendingDebt"
+  | "unPaid";
+export const ServiceStateEnum = /*@__PURE__*/ S.String;
+
+/** Details about a Service */
+export interface ServicesService {
+  /** Indicates that the service can be set up to be deleted at expiration */
+  canDeleteAtExpiration?: boolean;
+  contactAdmin?: string;
+  contactBilling?: string;
+  contactTech?: string;
+  creation?: string;
+  domain?: string;
+  engagedUpTo?: string | null;
+  expiration?: string;
+  /** All the possible renew period of your service in month */
+  possibleRenewPeriod?: ServicesServicePossibleRenewPeriodList | null;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+  renewalType?: ServiceRenewalTypeEnum;
+  serviceId?: number;
+  status?: ServiceStateEnum;
+}
+export const ServicesService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canDeleteAtExpiration: S.optional(S.Boolean),
+    contactAdmin: S.optional(S.String),
+    contactBilling: S.optional(S.String),
+    contactTech: S.optional(S.String),
+    creation: S.optional(S.String),
+    domain: S.optional(S.String),
+    engagedUpTo: S.optional(S.NullOr(S.String)),
+    expiration: S.optional(S.String),
+    possibleRenewPeriod: S.optional(
+      S.NullOr(ServicesServicePossibleRenewPeriodList),
+    ),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+    renewalType: S.optional(ServiceRenewalTypeEnum),
+    serviceId: S.optional(S.Number),
+    status: S.optional(ServiceStateEnum),
+  }),
+).annotate({
+  identifier: "ServicesService",
+}) as any as S.Schema<ServicesService>;
+
+export interface GetSslGatewayTaskRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Id of the task */
+  id: number;
+}
+export const GetSslGatewayTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/task/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSslGatewayTaskRequest",
+}) as any as S.Schema<GetSslGatewayTaskRequest>;
+
+/** Possible task action */
+export type SslGatewayTaskActionEnum =
+  | "addDomain"
+  | "addPaidCertificate"
+  | "addServer"
+  | "createService"
+  | "deleteDomain"
+  | "deleteServer"
+  | "deleteService"
+  | "internalTask"
+  | "updateServer"
+  | "updateService"
+  | "upgrade";
+export const SslGatewayTaskActionEnum = /*@__PURE__*/ S.String;
+
+/** Possible task status */
+export type SslGatewayTaskStatusEnum =
+  | "blocked"
+  | "cancelled"
+  | "doing"
+  | "done"
+  | "error"
+  | "paused"
+  | "todo";
+export const SslGatewayTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** SSL Gateway tasks */
+export interface SslGatewayTask {
+  /** The action made */
+  action?: SslGatewayTaskActionEnum;
+  /** Creation date of your task */
+  creationDate?: string;
+  /** Id of the task */
+  id?: number;
+  /** Task progress percentage */
+  progress?: number;
+  /** Current status of your task */
+  status?: SslGatewayTaskStatusEnum;
+}
+export const SslGatewayTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    action: S.optional(SslGatewayTaskActionEnum),
+    creationDate: S.optional(S.String),
+    id: S.optional(S.Number),
+    progress: S.optional(S.Number),
+    status: S.optional(SslGatewayTaskStatusEnum),
+  }),
+).annotate({ identifier: "SslGatewayTask" }) as any as S.Schema<SslGatewayTask>;
+
+/** 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 ListSslGatewayRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListSslGatewayRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListSslGatewayRequestIamTagsValueList>;
+
+export type ListSslGatewayRequestIamTagsMap = {
+  [key: string]: ListSslGatewayRequestIamTagsValueList | undefined;
+};
+export const ListSslGatewayRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListSslGatewayRequestIamTagsValueList,
+) as any as S.Schema<ListSslGatewayRequestIamTagsMap>;
+
+export interface ListSslGatewayRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListSslGatewayRequestIamTagsMap;
+}
+export const ListSslGatewayRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListSslGatewayRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/sslGateway", code: 200 })),
+).annotate({
+  identifier: "ListSslGatewayRequest",
+}) as any as S.Schema<ListSslGatewayRequest>;
+
+export type ListSslGatewayResponseBodyList = Array<string>;
+export const ListSslGatewayResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListSslGatewayResponseBodyList>;
+
+export type ListSslGatewayResponse = ListSslGatewayResponseBodyList;
+export const ListSslGatewayResponse = /*@__PURE__*/ S.suspend(() =>
+  ListSslGatewayResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSslGatewayResponse",
+}) as any as S.Schema<ListSslGatewayResponse>;
+
+export interface ListSslGatewayAvailableZonesRequest {}
+export const ListSslGatewayAvailableZonesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/sslGateway/availableZones", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListSslGatewayAvailableZonesRequest",
+}) as any as S.Schema<ListSslGatewayAvailableZonesRequest>;
+
+export type ListSslGatewayAvailableZonesResponseBodyList = Array<string>;
+export const ListSslGatewayAvailableZonesResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListSslGatewayAvailableZonesResponseBodyList>;
+
+export type ListSslGatewayAvailableZonesResponse =
+  ListSslGatewayAvailableZonesResponseBodyList;
+export const ListSslGatewayAvailableZonesResponse = /*@__PURE__*/ S.suspend(
+  () => ListSslGatewayAvailableZonesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSslGatewayAvailableZonesResponse",
+}) as any as S.Schema<ListSslGatewayAvailableZonesResponse>;
+
+export interface ListSslGatewayDomainRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const ListSslGatewayDomainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/domain",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListSslGatewayDomainRequest",
+}) as any as S.Schema<ListSslGatewayDomainRequest>;
+
+export type ListSslGatewayDomainResponseBodyList = Array<number>;
+export const ListSslGatewayDomainResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListSslGatewayDomainResponseBodyList>;
+
+export type ListSslGatewayDomainResponse = ListSslGatewayDomainResponseBodyList;
+export const ListSslGatewayDomainResponse = /*@__PURE__*/ S.suspend(() =>
+  ListSslGatewayDomainResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSslGatewayDomainResponse",
+}) as any as S.Schema<ListSslGatewayDomainResponse>;
+
+export interface ListSslGatewayEligibilityRequest {
+  /** domain to check eligibility for SSL Gateway offer */
+  domain: string;
+}
+export const ListSslGatewayEligibilityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    domain: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/sslGateway/eligibility", code: 200 })),
+).annotate({
+  identifier: "ListSslGatewayEligibilityRequest",
+}) as any as S.Schema<ListSslGatewayEligibilityRequest>;
+
+/** Eligible IP(s) v6 for this domain */
+export type SslGatewayEligibilityStatusIp6sList = Array<string>;
+export const SslGatewayEligibilityStatusIp6sList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SslGatewayEligibilityStatusIp6sList>;
+
+/** Eligible IP(s) for this domain */
+export type SslGatewayEligibilityStatusIpsList = Array<string>;
+export const SslGatewayEligibilityStatusIpsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SslGatewayEligibilityStatusIpsList>;
+
+/** A structure describing the eligibility status of a domain */
+export interface SslGatewayEligibilityStatus {
+  /** Customer domain name */
+  domain?: string;
+  /** Eligible IP(s) v6 for this domain */
+  ip6s?: SslGatewayEligibilityStatusIp6sList;
+  /** Eligible IP(s) for this domain */
+  ips?: SslGatewayEligibilityStatusIpsList;
+  /** Whether this domain is hosted by Ovh or not */
+  isHostedByOvh?: boolean;
+}
+export const SslGatewayEligibilityStatus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    domain: S.optional(S.String),
+    ip6s: S.optional(SslGatewayEligibilityStatusIp6sList),
+    ips: S.optional(SslGatewayEligibilityStatusIpsList),
+    isHostedByOvh: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "SslGatewayEligibilityStatus",
+}) as any as S.Schema<SslGatewayEligibilityStatus>;
+
+export interface ListSslGatewayNatIpRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const ListSslGatewayNatIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/natIp",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListSslGatewayNatIpRequest",
+}) as any as S.Schema<ListSslGatewayNatIpRequest>;
+
+export type SslGatewayNatIpsIpList = Array<string>;
+export const SslGatewayNatIpsIpList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SslGatewayNatIpsIpList>;
+
+/** a list of {zone, nat Ip} */
+export interface SslGatewayNatIps {
+  ip?: SslGatewayNatIpsIpList;
+  zone?: string;
+}
+export const SslGatewayNatIps = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.optional(SslGatewayNatIpsIpList),
+    zone: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "SslGatewayNatIps",
+}) as any as S.Schema<SslGatewayNatIps>;
+
+export type ListSslGatewayNatIpResponseBodyList = Array<SslGatewayNatIps>;
+export const ListSslGatewayNatIpResponseBodyList = /*@__PURE__*/ S.Array(
+  SslGatewayNatIps,
+) as any as S.Schema<ListSslGatewayNatIpResponseBodyList>;
+
+export type ListSslGatewayNatIpResponse = ListSslGatewayNatIpResponseBodyList;
+export const ListSslGatewayNatIpResponse = /*@__PURE__*/ S.suspend(() =>
+  ListSslGatewayNatIpResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSslGatewayNatIpResponse",
+}) as any as S.Schema<ListSslGatewayNatIpResponse>;
+
+export interface ListSslGatewayServerRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const ListSslGatewayServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sslGateway/{serviceName}/server",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListSslGatewayServerRequest",
+}) as any as S.Schema<ListSslGatewayServerRequest>;
+
+export type ListSslGatewayServerResponseBodyList = Array<number>;
+export const ListSslGatewayServerResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListSslGatewayServerResponseBodyList>;
+
+export type ListSslGatewayServerResponse = ListSslGatewayServerResponseBodyList;
+export const ListSslGatewayServerResponse = /*@__PURE__*/ S.suspend(() =>
+  ListSslGatewayServerResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSslGatewayServerResponse",
+}) as any as S.Schema<ListSslGatewayServerResponse>;
+
+export interface ListSslGatewayTaskRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const ListSslGatewayTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sslGateway/{serviceName}/task", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListSslGatewayTaskRequest",
+}) as any as S.Schema<ListSslGatewayTaskRequest>;
+
+export type ListSslGatewayTaskResponseBodyList = Array<number>;
+export const ListSslGatewayTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListSslGatewayTaskResponseBodyList>;
+
+export type ListSslGatewayTaskResponse = ListSslGatewayTaskResponseBodyList;
+export const ListSslGatewayTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListSslGatewayTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSslGatewayTaskResponse",
+}) as any as S.Schema<ListSslGatewayTaskResponse>;
+
+/** Restrict SSL Gateway access to these ip block. No restriction if null */
+export type PutSslGatewayRequestAllowedSourceList = Array<string>;
+export const PutSslGatewayRequestAllowedSourceList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<PutSslGatewayRequestAllowedSourceList>;
+
+export interface PutSslGatewayRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Restrict SSL Gateway access to these ip block. No restriction if null */
+  allowedSource?: PutSslGatewayRequestAllowedSourceList | null;
+  /** Custom name of your SSL Gateway */
+  displayName?: string | null;
+  /** Set to true to enable Strict-Transport-Security HTTP header */
+  hsts?: boolean;
+  /** Set to true to enable https redirect */
+  httpsRedirect?: boolean;
+  /** Custom reverse for your SSL Gateway */
+  reverse?: string | null;
+  /** Set to true to contact backend servers over HTTPS */
+  serverHttps?: boolean;
+  /** Modern oldest compatible clients : Firefox 27, Chrome 30, IE 11 on Windows 7, Edge, Opera 17, Safari 9, Android 5.0, and Java 8. Intermediate oldest compatible clients : Firefox 1, Chrome 1, IE 7, Opera 5, Safari 1, Windows XP IE8, Android 2.3, Java 7. Intermediate if null. */
+  sslConfiguration?: SslGatewaySslConfigurationEnum | (string & {}) | null;
+}
+export const PutSslGatewayRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    allowedSource: S.optional(S.NullOr(PutSslGatewayRequestAllowedSourceList)),
+    displayName: S.optional(S.NullOr(S.String)),
+    hsts: S.optional(S.Boolean),
+    httpsRedirect: S.optional(S.Boolean),
+    reverse: S.optional(S.NullOr(S.String)),
+    serverHttps: S.optional(S.Boolean),
+    sslConfiguration: S.optional(S.NullOr(SslGatewaySslConfigurationEnum)),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/sslGateway/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutSslGatewayRequest",
+}) as any as S.Schema<PutSslGatewayRequest>;
+
+export interface PutSslGatewayResponse {}
+export const PutSslGatewayResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutSslGatewayResponse",
+}) as any as S.Schema<PutSslGatewayResponse>;
+
+export interface PutSslGatewayServerRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Id of your server */
+  id: number;
+  /** IP address of the server attached to your SSL Gateway */
+  address?: string;
+  /** Port of your server attached to your SSL Gateway */
+  port?: number;
+}
+export const PutSslGatewayServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    address: S.optional(S.String),
+    port: S.optional(S.Number),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/sslGateway/{serviceName}/server/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutSslGatewayServerRequest",
+}) as any as S.Schema<PutSslGatewayServerRequest>;
+
+export interface PutSslGatewayServerResponse {}
+export const PutSslGatewayServerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutSslGatewayServerResponse",
+}) as any as S.Schema<PutSslGatewayServerResponse>;
+
+export interface PutSslGatewayServiceInfosRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutSslGatewayServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/sslGateway/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutSslGatewayServiceInfosRequest",
+}) as any as S.Schema<PutSslGatewayServiceInfosRequest>;
+
+export interface PutSslGatewayServiceInfosResponse {}
+export const PutSslGatewayServiceInfosResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutSslGatewayServiceInfosResponse",
+}) as any as S.Schema<PutSslGatewayServiceInfosResponse>;
+
+export interface RenewSslGatewayCertificateRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+  /** Domain on which you want to renew certificate */
+  domain?: string;
+}
+export const RenewSslGatewayCertificateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    domain: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sslGateway/{serviceName}/renewCertificate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RenewSslGatewayCertificateRequest",
+}) as any as S.Schema<RenewSslGatewayCertificateRequest>;
+
+export type RenewSslGatewayCertificateResponseBodyList = Array<string>;
+export const RenewSslGatewayCertificateResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RenewSslGatewayCertificateResponseBodyList>;
+
+export type RenewSslGatewayCertificateResponse =
+  RenewSslGatewayCertificateResponseBodyList;
+export const RenewSslGatewayCertificateResponse = /*@__PURE__*/ S.suspend(() =>
+  RenewSslGatewayCertificateResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RenewSslGatewayCertificateResponse",
+}) as any as S.Schema<RenewSslGatewayCertificateResponse>;
+
+export interface TerminateSslGatewayRequest {
+  /** The internal name of your SSL Gateway */
+  serviceName: string;
+}
+export const TerminateSslGatewayRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sslGateway/{serviceName}/terminate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TerminateSslGatewayRequest",
+}) as any as S.Schema<TerminateSslGatewayRequest>;
+
+export type TerminateSslGatewayResponse = string;
+export const TerminateSslGatewayResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateSslGatewayResponse",
+}) as any as S.Schema<TerminateSslGatewayResponse>;
+
+export type ConfirmSslGatewayTerminationError = OvhOpError;
+/** Confirm service termination */
+export const confirmSslGatewayTermination: API.OperationMethod<
+  ConfirmSslGatewayTerminationRequest,
+  ConfirmSslGatewayTerminationResponse,
+  ConfirmSslGatewayTerminationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfirmSslGatewayTerminationRequest,
+  output: ConfirmSslGatewayTerminationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSslGatewayChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createSslGatewayChangeContact: API.OperationMethod<
+  CreateSslGatewayChangeContactRequest,
+  CreateSslGatewayChangeContactResponse,
+  CreateSslGatewayChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSslGatewayChangeContactRequest,
+  output: CreateSslGatewayChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSslGatewayDomainError = OvhOpError;
+/** Attach a new domain to your SSL Gateway */
+export const createSslGatewayDomain: API.OperationMethod<
+  CreateSslGatewayDomainRequest,
+  SslGatewayDomain,
+  CreateSslGatewayDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSslGatewayDomainRequest,
+  output: SslGatewayDomain,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSslGatewayServerError = OvhOpError;
+/** Add a new server to your SSL Gateway */
+export const createSslGatewayServer: API.OperationMethod<
+  CreateSslGatewayServerRequest,
+  SslGatewayServer,
+  CreateSslGatewayServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSslGatewayServerRequest,
+  output: SslGatewayServer,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteSslGatewayDomainError = OvhOpError;
+/** Detach a domain from your SSL Gateway */
+export const deleteSslGatewayDomain: API.OperationMethod<
+  DeleteSslGatewayDomainRequest,
+  DeleteSslGatewayDomainResponse,
+  DeleteSslGatewayDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteSslGatewayDomainRequest,
+  output: DeleteSslGatewayDomainResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteSslGatewayServerError = OvhOpError;
+/** Remove a server */
+export const deleteSslGatewayServer: API.OperationMethod<
+  DeleteSslGatewayServerRequest,
+  DeleteSslGatewayServerResponse,
+  DeleteSslGatewayServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteSslGatewayServerRequest,
+  output: DeleteSslGatewayServerResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSslGatewayError = OvhOpError;
+/** Get this object properties */
+export const getSslGateway: API.OperationMethod<
+  GetSslGatewayRequest,
+  SslGatewaySslGatewayWithIAM,
+  GetSslGatewayError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSslGatewayRequest,
+  output: SslGatewaySslGatewayWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSslGatewayDomainError = OvhOpError;
+/** Get this object properties */
+export const getSslGatewayDomain: API.OperationMethod<
+  GetSslGatewayDomainRequest,
+  SslGatewayDomain,
+  GetSslGatewayDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSslGatewayDomainRequest,
+  output: SslGatewayDomain,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSslGatewayServerError = OvhOpError;
+/** Get this object properties */
+export const getSslGatewayServer: API.OperationMethod<
+  GetSslGatewayServerRequest,
+  SslGatewayServer,
+  GetSslGatewayServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSslGatewayServerRequest,
+  output: SslGatewayServer,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSslGatewayServiceInfosError = OvhOpError;
+/** Get service information */
+export const getSslGatewayServiceInfos: API.OperationMethod<
+  GetSslGatewayServiceInfosRequest,
+  ServicesService,
+  GetSslGatewayServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSslGatewayServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSslGatewayTaskError = OvhOpError;
+/** Get this object properties */
+export const getSslGatewayTask: API.OperationMethod<
+  GetSslGatewayTaskRequest,
+  SslGatewayTask,
+  GetSslGatewayTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSslGatewayTaskRequest,
+  output: SslGatewayTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayError = OvhOpError;
+/** List of your SSL Gateways */
+export const listSslGateway: API.OperationMethod<
+  ListSslGatewayRequest,
+  ListSslGatewayResponse,
+  ListSslGatewayError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayRequest,
+  output: ListSslGatewayResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayAvailableZonesError = OvhOpError;
+/** List of zone available for an SSL Gateway */
+export const listSslGatewayAvailableZones: API.OperationMethod<
+  ListSslGatewayAvailableZonesRequest,
+  ListSslGatewayAvailableZonesResponse,
+  ListSslGatewayAvailableZonesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayAvailableZonesRequest,
+  output: ListSslGatewayAvailableZonesResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayDomainError = OvhOpError;
+/** Domains attached to your SSL Gateway */
+export const listSslGatewayDomain: API.OperationMethod<
+  ListSslGatewayDomainRequest,
+  ListSslGatewayDomainResponse,
+  ListSslGatewayDomainError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayDomainRequest,
+  output: ListSslGatewayDomainResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayEligibilityError = OvhOpError;
+/** Check domain eligibility. Return list of eligible IP(s) for this domain. */
+export const listSslGatewayEligibility: API.OperationMethod<
+  ListSslGatewayEligibilityRequest,
+  SslGatewayEligibilityStatus,
+  ListSslGatewayEligibilityError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayEligibilityRequest,
+  output: SslGatewayEligibilityStatus,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayNatIpError = OvhOpError;
+/** Ip subnet used by OVH to nat requests to your SSL Gateway backends. */
+export const listSslGatewayNatIp: API.OperationMethod<
+  ListSslGatewayNatIpRequest,
+  ListSslGatewayNatIpResponse,
+  ListSslGatewayNatIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayNatIpRequest,
+  output: ListSslGatewayNatIpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayServerError = OvhOpError;
+/** Servers attached to your SSL Gateway */
+export const listSslGatewayServer: API.OperationMethod<
+  ListSslGatewayServerRequest,
+  ListSslGatewayServerResponse,
+  ListSslGatewayServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayServerRequest,
+  output: ListSslGatewayServerResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSslGatewayTaskError = OvhOpError;
+/** Task for this SSL Gateway */
+export const listSslGatewayTask: API.OperationMethod<
+  ListSslGatewayTaskRequest,
+  ListSslGatewayTaskResponse,
+  ListSslGatewayTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSslGatewayTaskRequest,
+  output: ListSslGatewayTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutSslGatewayError = OvhOpError;
+/** Alter this object properties */
+export const putSslGateway: API.OperationMethod<
+  PutSslGatewayRequest,
+  PutSslGatewayResponse,
+  PutSslGatewayError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutSslGatewayRequest,
+  output: PutSslGatewayResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutSslGatewayServerError = OvhOpError;
+/** Alter this object properties */
+export const putSslGatewayServer: API.OperationMethod<
+  PutSslGatewayServerRequest,
+  PutSslGatewayServerResponse,
+  PutSslGatewayServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutSslGatewayServerRequest,
+  output: PutSslGatewayServerResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutSslGatewayServiceInfosError = OvhOpError;
+/** Update service information */
+export const putSslGatewayServiceInfos: API.OperationMethod<
+  PutSslGatewayServiceInfosRequest,
+  PutSslGatewayServiceInfosResponse,
+  PutSslGatewayServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutSslGatewayServiceInfosRequest,
+  output: PutSslGatewayServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RenewSslGatewayCertificateError = OvhOpError;
+/** Renew your SSL certificates */
+export const renewSslGatewayCertificate: API.OperationMethod<
+  RenewSslGatewayCertificateRequest,
+  RenewSslGatewayCertificateResponse,
+  RenewSslGatewayCertificateError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RenewSslGatewayCertificateRequest,
+  output: RenewSslGatewayCertificateResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateSslGatewayError = OvhOpError;
+/** Ask for the termination of your service Ask for the termination of your service. Admin contact of this service will receive a termination token by email in order to confirm its termination with /confirmTermination endpoint. */
+export const terminateSslGateway: API.OperationMethod<
+  TerminateSslGatewayRequest,
+  TerminateSslGatewayResponse,
+  TerminateSslGatewayError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateSslGatewayRequest,
+  output: TerminateSslGatewayResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));