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

package/lib/services/iploadbalancing.js

@@ -0,0 +1,3554 @@
+// 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.js";
+import { OvhProtocol, } from "../protocol.js";
+import { UnknownOvhError } from "../errors.js";
+import * as Retry from "../retry.js";
+export const CancelIpLoadbalancingZoneTerminationRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/zone/{name}/cancelTermination",
+    code: 200,
+}))).annotate({
+    identifier: "CancelIpLoadbalancingZoneTerminationRequest",
+});
+export const CancelIpLoadbalancingZoneTerminationResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "CancelIpLoadbalancingZoneTerminationResponse",
+});
+export const ServiceTerminationFutureUseEnum = /*@__PURE__*/ S.String;
+export const ServiceTerminationReasonEnum = /*@__PURE__*/ S.String;
+export const ConfirmIpLoadbalancingTerminationRequest = /*@__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: "/ipLoadbalancing/{serviceName}/confirmTermination",
+    code: 200,
+}))).annotate({
+    identifier: "ConfirmIpLoadbalancingTerminationRequest",
+});
+export const ConfirmIpLoadbalancingTerminationResponse = 
+/*@__PURE__*/ S.suspend(() => S.String.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ConfirmIpLoadbalancingTerminationResponse",
+});
+export const CreateIpLoadbalancingChangeContactRequest = 
+/*@__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: "/ipLoadbalancing/{serviceName}/changeContact",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingChangeContactRequest",
+});
+export const CreateIpLoadbalancingChangeContactResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const CreateIpLoadbalancingChangeContactResponse = 
+/*@__PURE__*/ S.suspend(() => CreateIpLoadbalancingChangeContactResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "CreateIpLoadbalancingChangeContactResponse",
+});
+export const CreateIpLoadbalancingFreeCertificateRequestFqdnList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingFreeCertificateRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    fqdn: CreateIpLoadbalancingFreeCertificateRequestFqdnList,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/freeCertificate",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingFreeCertificateRequest",
+});
+export const IpLoadbalancingTaskActionEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingTaskStatusEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingTaskTaskZonesList = /*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingTaskTask = /*@__PURE__*/ S.suspend(() => S.Struct({
+    action: S.optional(IpLoadbalancingTaskActionEnum),
+    creationDate: S.optional(S.String),
+    doneDate: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.Number),
+    progress: S.optional(S.Number),
+    status: S.optional(IpLoadbalancingTaskStatusEnum),
+    zones: S.optional(IpLoadbalancingTaskTaskZonesList),
+})).annotate({
+    identifier: "IpLoadbalancingTaskTask",
+});
+export const IpLoadbalancingBalanceHTTPEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingProbeExpectMatchEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingProbeMethodEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingProbeTypeEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingBackendProbe = /*@__PURE__*/ S.suspend(() => S.Struct({
+    forceSsl: S.optional(S.NullOr(S.Boolean)),
+    interval: S.optional(S.NullOr(S.Number)),
+    match: S.optional(S.NullOr(IpLoadbalancingProbeExpectMatchEnum)),
+    method: S.optional(S.NullOr(IpLoadbalancingProbeMethodEnum)),
+    negate: S.optional(S.NullOr(S.Boolean)),
+    pattern: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.NullOr(S.Number)),
+    type: S.optional(S.NullOr(IpLoadbalancingProbeTypeEnum)),
+    url: S.optional(S.NullOr(S.String)),
+})).annotate({
+    identifier: "IpLoadbalancingBackendProbe",
+});
+export const IpLoadbalancingStickinessHTTPEnum = /*@__PURE__*/ S.String;
+export const CreateIpLoadbalancingHttpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    balance: S.optional(IpLoadbalancingBalanceHTTPEnum),
+    displayName: S.optional(S.String),
+    port: S.optional(S.Number),
+    probe: S.optional(IpLoadbalancingBackendProbe),
+    stickiness: S.optional(IpLoadbalancingStickinessHTTPEnum),
+    vrackNetworkId: S.optional(S.Number),
+    zone: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpFarmRequest",
+});
+export const IpLoadbalancingBackendHttpBackendHttp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    balance: S.optional(S.NullOr(IpLoadbalancingBalanceHTTPEnum)),
+    displayName: S.optional(S.NullOr(S.String)),
+    farmId: S.optional(S.Number),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.NullOr(IpLoadbalancingBackendProbe)),
+    stickiness: S.optional(S.NullOr(IpLoadbalancingStickinessHTTPEnum)),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingBackendHttpBackendHttp",
+});
+export const IpLoadbalancingOnMarkedDownEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingProxyProtocolVersionEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingBackendCustomerServerStatusEnum = 
+/*@__PURE__*/ S.String;
+export const CreateIpLoadbalancingHttpFarmServerRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    address: S.String,
+    backup: S.optional(S.Boolean),
+    chain: S.optional(S.String),
+    cookie: S.optional(S.String),
+    displayName: S.optional(S.String),
+    onMarkedDown: S.optional(IpLoadbalancingOnMarkedDownEnum),
+    port: S.optional(S.Number),
+    probe: S.optional(S.Boolean),
+    proxyProtocolVersion: S.optional(IpLoadbalancingProxyProtocolVersionEnum),
+    ssl: S.optional(S.Boolean),
+    status: IpLoadbalancingBackendCustomerServerStatusEnum,
+    weight: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpFarmServerRequest",
+});
+export const IpLoadbalancingServerState = /*@__PURE__*/ S.suspend(() => S.Struct({
+    checkCode: S.optional(S.NullOr(S.String)),
+    checkStatus: S.optional(S.NullOr(S.String)),
+    checkTime: S.optional(S.NullOr(S.String)),
+    instanceId: S.optional(S.Number),
+    lastCheckContent: S.optional(S.NullOr(S.String)),
+    status: S.optional(S.NullOr(S.String)),
+})).annotate({
+    identifier: "IpLoadbalancingServerState",
+});
+export const IpLoadbalancingBackendHttpCustomerServerBackendHTTPServerServerStateList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingServerState);
+export const IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    address: S.optional(S.String),
+    backendId: S.optional(S.Number),
+    backup: S.optional(S.Boolean),
+    chain: S.optional(S.NullOr(S.String)),
+    cookie: S.optional(S.NullOr(S.String)),
+    displayName: S.optional(S.NullOr(S.String)),
+    onMarkedDown: S.optional(S.NullOr(IpLoadbalancingOnMarkedDownEnum)),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.Boolean),
+    proxyProtocolVersion: S.optional(S.NullOr(IpLoadbalancingProxyProtocolVersionEnum)),
+    serverId: S.optional(S.Number),
+    serverState: S.optional(IpLoadbalancingBackendHttpCustomerServerBackendHTTPServerServerStateList),
+    ssl: S.optional(S.Boolean),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum),
+    weight: S.optional(S.NullOr(S.Number)),
+})).annotate({
+    identifier: "IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer",
+});
+export const CreateIpLoadbalancingHttpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    address: S.String,
+    slotId: S.Number,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}/transparent",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpFarmServerTransparentRequest",
+});
+export const IpLoadbalancingVrackTransparentIpVrackTransparentIp = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    address: S.optional(S.String),
+    farmId: S.optional(S.Number),
+    id: S.optional(S.Number),
+    serverId: S.optional(S.Number),
+    slotId: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingVrackTransparentIpVrackTransparentIp",
+});
+export const CreateIpLoadbalancingHttpFrontendRequestAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingHttpFrontendRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingHttpFrontendRequestDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingHttpFrontendRequestHttpHeaderList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingHttpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    allowedSource: S.optional(CreateIpLoadbalancingHttpFrontendRequestAllowedSourceList),
+    dedicatedIpfo: S.optional(CreateIpLoadbalancingHttpFrontendRequestDedicatedIpfoList),
+    defaultFarmId: S.optional(S.Number),
+    defaultSslId: S.optional(S.Number),
+    deniedSource: S.optional(CreateIpLoadbalancingHttpFrontendRequestDeniedSourceList),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.String),
+    hsts: S.optional(S.Boolean),
+    httpHeader: S.optional(CreateIpLoadbalancingHttpFrontendRequestHttpHeaderList),
+    port: S.String,
+    redirectLocation: S.optional(S.String),
+    ssl: S.optional(S.Boolean),
+    zone: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/frontend",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpFrontendRequest",
+});
+export const IpLoadbalancingFrontendHttpFrontendHttpAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendHttpFrontendHttpDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendHttpFrontendHttpDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendHttpFrontendHttpHttpHeaderList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendHttpFrontendHttp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    allowedSource: S.optional(S.NullOr(IpLoadbalancingFrontendHttpFrontendHttpAllowedSourceList)),
+    dedicatedIpfo: S.optional(S.NullOr(IpLoadbalancingFrontendHttpFrontendHttpDedicatedIpfoList)),
+    defaultFarmId: S.optional(S.NullOr(S.Number)),
+    defaultSslId: S.optional(S.NullOr(S.Number)),
+    deniedSource: S.optional(S.NullOr(IpLoadbalancingFrontendHttpFrontendHttpDeniedSourceList)),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.Number),
+    hsts: S.optional(S.Boolean),
+    httpHeader: S.optional(S.NullOr(IpLoadbalancingFrontendHttpFrontendHttpHttpHeaderList)),
+    port: S.optional(S.String),
+    redirectLocation: S.optional(S.NullOr(S.String)),
+    ssl: S.optional(S.Boolean),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+    vrackVrouterId: S.optional(S.NullOr(S.Number)),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingFrontendHttpFrontendHttp",
+});
+export const CreateIpLoadbalancingHttpFrontendPrivateRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingHttpFrontendPrivateRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+    dedicatedIpfo: S.optional(CreateIpLoadbalancingHttpFrontendPrivateRequestDedicatedIpfoList),
+    vrackNetworkId: S.optional(S.Number),
+    vrackVrouterId: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/frontend/{frontendId}/private",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpFrontendPrivateRequest",
+});
+export const IpLoadbalancingFrontendFrontendAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendFrontendDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendFrontendDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendFrontendHttpHeaderList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingProxyTypeEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingFrontendFrontend = /*@__PURE__*/ S.suspend(() => S.Struct({
+    allowedSource: S.optional(S.NullOr(IpLoadbalancingFrontendFrontendAllowedSourceList)),
+    dedicatedIpfo: S.optional(S.NullOr(IpLoadbalancingFrontendFrontendDedicatedIpfoList)),
+    defaultBackendId: S.optional(S.NullOr(S.Number)),
+    defaultSslId: S.optional(S.NullOr(S.Number)),
+    deniedSource: S.optional(S.NullOr(IpLoadbalancingFrontendFrontendDeniedSourceList)),
+    disabled: S.optional(S.Boolean),
+    hsts: S.optional(S.Boolean),
+    httpHeader: S.optional(S.NullOr(IpLoadbalancingFrontendFrontendHttpHeaderList)),
+    id: S.optional(S.Number),
+    port: S.optional(S.String),
+    redirectLocation: S.optional(S.NullOr(S.String)),
+    ssl: S.optional(S.Boolean),
+    type: S.optional(IpLoadbalancingProxyTypeEnum),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingFrontendFrontend",
+});
+export const IpLoadbalancingRouteHttpAction = /*@__PURE__*/ S.suspend(() => S.Struct({
+    status: S.optional(S.NullOr(S.Number)),
+    target: S.optional(S.NullOr(S.String)),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingRouteHttpAction",
+});
+export const CreateIpLoadbalancingHttpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    action: IpLoadbalancingRouteHttpAction,
+    displayName: S.optional(S.String),
+    frontendId: S.optional(S.Number),
+    weight: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/route",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpRouteRequest",
+});
+export const IpLoadbalancingRouteRuleMatchesEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingRouteRule = /*@__PURE__*/ S.suspend(() => S.Struct({
+    field: S.optional(S.String),
+    match: S.optional(IpLoadbalancingRouteRuleMatchesEnum),
+    negate: S.optional(S.Boolean),
+    pattern: S.optional(S.NullOr(S.String)),
+    ruleId: S.optional(S.Number),
+    subField: S.optional(S.NullOr(S.String)),
+})).annotate({
+    identifier: "IpLoadbalancingRouteRule",
+});
+export const IpLoadbalancingRouteHttpRouteHttpRulesList = /*@__PURE__*/ S.Array(IpLoadbalancingRouteRule);
+export const IpLoadbalancingRouteStatusEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingRouteHttpRouteHttp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    action: S.optional(IpLoadbalancingRouteHttpAction),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.NullOr(S.Number)),
+    routeId: S.optional(S.Number),
+    rules: S.optional(IpLoadbalancingRouteHttpRouteHttpRulesList),
+    status: S.optional(IpLoadbalancingRouteStatusEnum),
+    weight: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingRouteHttpRouteHttp",
+});
+export const CreateIpLoadbalancingHttpRouteRuleRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    field: S.String,
+    match: IpLoadbalancingRouteRuleMatchesEnum,
+    negate: S.optional(S.Boolean),
+    pattern: S.optional(S.String),
+    subField: S.optional(S.String),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}/rule",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingHttpRouteRuleRequest",
+});
+export const IpLoadbalancingRouteRuleRouteRule = /*@__PURE__*/ S.suspend(() => S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    field: S.optional(S.String),
+    match: S.optional(IpLoadbalancingRouteRuleMatchesEnum),
+    negate: S.optional(S.Boolean),
+    pattern: S.optional(S.NullOr(S.String)),
+    ruleId: S.optional(S.Number),
+    subField: S.optional(S.NullOr(S.String)),
+})).annotate({
+    identifier: "IpLoadbalancingRouteRuleRouteRule",
+});
+export const CreateIpLoadbalancingLogSubscriptionRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    kind: S.String,
+    streamId: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/log/subscription",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingLogSubscriptionRequest",
+});
+export const IpLoadbalancingLogSubscriptionResponse = /*@__PURE__*/ S.suspend(() => S.Struct({
+    operationId: S.optional(S.String),
+    serviceName: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingLogSubscriptionResponse",
+});
+export const CreateIpLoadbalancingLogUrlRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    kind: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/log/url",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingLogUrlRequest",
+});
+export const IpLoadbalancingLogUrl = /*@__PURE__*/ S.suspend(() => S.Struct({
+    expirationDate: S.optional(S.String),
+    url: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingLogUrl",
+});
+export const CreateIpLoadbalancingSslRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    certificate: S.String,
+    chain: S.optional(S.String),
+    displayName: S.optional(S.String),
+    key: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/ssl",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingSslRequest",
+});
+export const IpLoadbalancingSslSslSanList = /*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingSslTypeEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingSslSsl = /*@__PURE__*/ S.suspend(() => S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    expireDate: S.optional(S.String),
+    fingerprint: S.optional(S.String),
+    id: S.optional(S.Number),
+    san: S.optional(IpLoadbalancingSslSslSanList),
+    serial: S.optional(S.String),
+    subject: S.optional(S.String),
+    type: S.optional(S.NullOr(IpLoadbalancingSslTypeEnum)),
+})).annotate({
+    identifier: "IpLoadbalancingSslSsl",
+});
+export const IpLoadbalancingBalanceTCPEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingStickinessTCPEnum = /*@__PURE__*/ S.String;
+export const CreateIpLoadbalancingTcpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    balance: S.optional(IpLoadbalancingBalanceTCPEnum),
+    displayName: S.optional(S.String),
+    port: S.optional(S.Number),
+    probe: S.optional(IpLoadbalancingBackendProbe),
+    stickiness: S.optional(IpLoadbalancingStickinessTCPEnum),
+    vrackNetworkId: S.optional(S.Number),
+    zone: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpFarmRequest",
+});
+export const IpLoadbalancingBackendTcpBackendTcp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    balance: S.optional(S.NullOr(IpLoadbalancingBalanceTCPEnum)),
+    displayName: S.optional(S.NullOr(S.String)),
+    farmId: S.optional(S.Number),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.NullOr(IpLoadbalancingBackendProbe)),
+    stickiness: S.optional(S.NullOr(IpLoadbalancingStickinessTCPEnum)),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingBackendTcpBackendTcp",
+});
+export const CreateIpLoadbalancingTcpFarmServerRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    address: S.String,
+    backup: S.optional(S.Boolean),
+    chain: S.optional(S.String),
+    displayName: S.optional(S.String),
+    onMarkedDown: S.optional(IpLoadbalancingOnMarkedDownEnum),
+    port: S.optional(S.Number),
+    probe: S.optional(S.Boolean),
+    proxyProtocolVersion: S.optional(IpLoadbalancingProxyProtocolVersionEnum),
+    ssl: S.optional(S.Boolean),
+    status: IpLoadbalancingBackendCustomerServerStatusEnum,
+    weight: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpFarmServerRequest",
+});
+export const IpLoadbalancingBackendTcpCustomerServerBackendTCPServerServerStateList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingServerState);
+export const IpLoadbalancingBackendTcpCustomerServerBackendTCPServer = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    address: S.optional(S.String),
+    backendId: S.optional(S.Number),
+    backup: S.optional(S.Boolean),
+    chain: S.optional(S.NullOr(S.String)),
+    displayName: S.optional(S.NullOr(S.String)),
+    onMarkedDown: S.optional(S.NullOr(IpLoadbalancingOnMarkedDownEnum)),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.Boolean),
+    proxyProtocolVersion: S.optional(S.NullOr(IpLoadbalancingProxyProtocolVersionEnum)),
+    serverId: S.optional(S.Number),
+    serverState: S.optional(IpLoadbalancingBackendTcpCustomerServerBackendTCPServerServerStateList),
+    ssl: S.optional(S.Boolean),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum),
+    weight: S.optional(S.NullOr(S.Number)),
+})).annotate({
+    identifier: "IpLoadbalancingBackendTcpCustomerServerBackendTCPServer",
+});
+export const CreateIpLoadbalancingTcpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    address: S.String,
+    slotId: S.Number,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}/transparent",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpFarmServerTransparentRequest",
+});
+export const CreateIpLoadbalancingTcpFrontendRequestAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingTcpFrontendRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingTcpFrontendRequestDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingTcpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    allowedSource: S.optional(CreateIpLoadbalancingTcpFrontendRequestAllowedSourceList),
+    dedicatedIpfo: S.optional(CreateIpLoadbalancingTcpFrontendRequestDedicatedIpfoList),
+    defaultFarmId: S.optional(S.Number),
+    defaultSslId: S.optional(S.Number),
+    deniedSource: S.optional(CreateIpLoadbalancingTcpFrontendRequestDeniedSourceList),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.String),
+    port: S.String,
+    ssl: S.optional(S.Boolean),
+    zone: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/frontend",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpFrontendRequest",
+});
+export const IpLoadbalancingFrontendTcpFrontendTcpAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendTcpFrontendTcpDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendTcpFrontendTcpDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendTcpFrontendTcp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    allowedSource: S.optional(S.NullOr(IpLoadbalancingFrontendTcpFrontendTcpAllowedSourceList)),
+    dedicatedIpfo: S.optional(S.NullOr(IpLoadbalancingFrontendTcpFrontendTcpDedicatedIpfoList)),
+    defaultFarmId: S.optional(S.NullOr(S.Number)),
+    defaultSslId: S.optional(S.NullOr(S.Number)),
+    deniedSource: S.optional(S.NullOr(IpLoadbalancingFrontendTcpFrontendTcpDeniedSourceList)),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.Number),
+    port: S.optional(S.String),
+    ssl: S.optional(S.Boolean),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+    vrackVrouterId: S.optional(S.NullOr(S.Number)),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingFrontendTcpFrontendTcp",
+});
+export const CreateIpLoadbalancingTcpFrontendPrivateRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingTcpFrontendPrivateRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+    dedicatedIpfo: S.optional(CreateIpLoadbalancingTcpFrontendPrivateRequestDedicatedIpfoList),
+    vrackNetworkId: S.optional(S.Number),
+    vrackVrouterId: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/frontend/{frontendId}/private",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpFrontendPrivateRequest",
+});
+export const IpLoadbalancingRouteTcpAction = /*@__PURE__*/ S.suspend(() => S.Struct({
+    target: S.optional(S.NullOr(S.String)),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingRouteTcpAction",
+});
+export const CreateIpLoadbalancingTcpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    action: IpLoadbalancingRouteTcpAction,
+    displayName: S.optional(S.String),
+    frontendId: S.optional(S.Number),
+    weight: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpRouteRequest",
+});
+export const IpLoadbalancingRouteTcpRouteTcpRulesList = /*@__PURE__*/ S.Array(IpLoadbalancingRouteRule);
+export const IpLoadbalancingRouteTcpRouteTcp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    action: S.optional(IpLoadbalancingRouteTcpAction),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.NullOr(S.Number)),
+    routeId: S.optional(S.Number),
+    rules: S.optional(IpLoadbalancingRouteTcpRouteTcpRulesList),
+    status: S.optional(IpLoadbalancingRouteStatusEnum),
+    weight: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingRouteTcpRouteTcp",
+});
+export const CreateIpLoadbalancingTcpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    field: S.String,
+    match: IpLoadbalancingRouteRuleMatchesEnum,
+    negate: S.optional(S.Boolean),
+    pattern: S.optional(S.String),
+    subField: S.optional(S.String),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}/rule",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingTcpRouteRuleRequest",
+});
+export const CreateIpLoadbalancingUdpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    port: S.Number,
+    vrackNetworkId: S.optional(S.Number),
+    zone: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingUdpFarmRequest",
+});
+export const IpLoadbalancingBackendUdpBackendUdp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    farmId: S.optional(S.Number),
+    port: S.optional(S.Number),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingBackendUdpBackendUdp",
+});
+export const CreateIpLoadbalancingUdpFarmServerRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    address: S.String,
+    displayName: S.optional(S.String),
+    port: S.optional(S.Number),
+    status: IpLoadbalancingBackendCustomerServerStatusEnum,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}/server",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingUdpFarmServerRequest",
+});
+export const IpLoadbalancingBackendUdpCustomerServerBackendUDPServer = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    address: S.optional(S.String),
+    backendId: S.optional(S.Number),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.NullOr(S.Number)),
+    serverId: S.optional(S.Number),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum),
+})).annotate({
+    identifier: "IpLoadbalancingBackendUdpCustomerServerBackendUDPServer",
+});
+export const CreateIpLoadbalancingUdpFrontendRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const CreateIpLoadbalancingUdpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedIpfo: S.optional(CreateIpLoadbalancingUdpFrontendRequestDedicatedIpfoList),
+    defaultFarmId: S.optional(S.Number),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.String),
+    port: S.String,
+    zone: S.String,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/udp/frontend",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingUdpFrontendRequest",
+});
+export const IpLoadbalancingFrontendUdpFrontendUdpDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFrontendUdpFrontendUdp = /*@__PURE__*/ S.suspend(() => S.Struct({
+    dedicatedIpfo: S.optional(S.NullOr(IpLoadbalancingFrontendUdpFrontendUdpDedicatedIpfoList)),
+    defaultFarmId: S.optional(S.NullOr(S.Number)),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.Number),
+    port: S.optional(S.String),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingFrontendUdpFrontendUdp",
+});
+export const CreateIpLoadbalancingVrackNetworkRequestFarmIdList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const CreateIpLoadbalancingVrackNetworkRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    farmId: S.optional(CreateIpLoadbalancingVrackNetworkRequestFarmIdList),
+    natIp: S.String,
+    subnet: S.String,
+    vlan: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/network",
+    code: 200,
+}))).annotate({
+    identifier: "CreateIpLoadbalancingVrackNetworkRequest",
+});
+export const IpLoadbalancingDefinedFarm = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.optional(S.Number),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingDefinedFarm",
+});
+export const IpLoadbalancingVrackNetworkVrackNetworkFarmIdList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingDefinedFarm);
+export const IpLoadbalancingVrackNetworkVrackNetwork = /*@__PURE__*/ S.suspend(() => S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    farmId: S.optional(IpLoadbalancingVrackNetworkVrackNetworkFarmIdList),
+    natIp: S.optional(S.String),
+    subnet: S.optional(S.String),
+    vlan: S.optional(S.Number),
+    vrackNetworkId: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingVrackNetworkVrackNetwork",
+});
+export const DeleteIpLoadbalancingHttpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFarmRequest",
+});
+export const DeleteIpLoadbalancingHttpFarmResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFarmResponse",
+});
+export const DeleteIpLoadbalancingHttpFarmServerRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFarmServerRequest",
+});
+export const DeleteIpLoadbalancingHttpFarmServerResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFarmServerResponse",
+});
+export const DeleteIpLoadbalancingHttpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    transparentId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}/transparent/{transparentId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFarmServerTransparentRequest",
+});
+export const DeleteIpLoadbalancingHttpFarmServerTransparentResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFarmServerTransparentResponse",
+});
+export const DeleteIpLoadbalancingHttpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/http/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFrontendRequest",
+});
+export const DeleteIpLoadbalancingHttpFrontendResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingHttpFrontendResponse",
+});
+export const DeleteIpLoadbalancingHttpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingHttpRouteRequest",
+});
+export const DeleteIpLoadbalancingHttpRouteResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingHttpRouteResponse",
+});
+export const DeleteIpLoadbalancingHttpRouteRuleRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    ruleId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}/rule/{ruleId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingHttpRouteRuleRequest",
+});
+export const DeleteIpLoadbalancingHttpRouteRuleResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingHttpRouteRuleResponse",
+});
+export const DeleteIpLoadbalancingLogSubscriptionRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    subscriptionId: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/log/subscription/{subscriptionId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingLogSubscriptionRequest",
+});
+export const DeleteIpLoadbalancingSslRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/ssl/{id}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingSslRequest",
+});
+export const DeleteIpLoadbalancingSslResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingSslResponse",
+});
+export const DeleteIpLoadbalancingTcpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFarmRequest",
+});
+export const DeleteIpLoadbalancingTcpFarmResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFarmResponse",
+});
+export const DeleteIpLoadbalancingTcpFarmServerRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFarmServerRequest",
+});
+export const DeleteIpLoadbalancingTcpFarmServerResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFarmServerResponse",
+});
+export const DeleteIpLoadbalancingTcpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    transparentId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}/transparent/{transparentId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFarmServerTransparentRequest",
+});
+export const DeleteIpLoadbalancingTcpFarmServerTransparentResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFarmServerTransparentResponse",
+});
+export const DeleteIpLoadbalancingTcpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFrontendRequest",
+});
+export const DeleteIpLoadbalancingTcpFrontendResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingTcpFrontendResponse",
+});
+export const DeleteIpLoadbalancingTcpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingTcpRouteRequest",
+});
+export const DeleteIpLoadbalancingTcpRouteResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingTcpRouteResponse",
+});
+export const DeleteIpLoadbalancingTcpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    ruleId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}/rule/{ruleId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingTcpRouteRuleRequest",
+});
+export const DeleteIpLoadbalancingTcpRouteRuleResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingTcpRouteRuleResponse",
+});
+export const DeleteIpLoadbalancingUdpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingUdpFarmRequest",
+});
+export const DeleteIpLoadbalancingUdpFarmResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingUdpFarmResponse",
+});
+export const DeleteIpLoadbalancingUdpFarmServerRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingUdpFarmServerRequest",
+});
+export const DeleteIpLoadbalancingUdpFarmServerResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingUdpFarmServerResponse",
+});
+export const DeleteIpLoadbalancingUdpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/udp/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingUdpFrontendRequest",
+});
+export const DeleteIpLoadbalancingUdpFrontendResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingUdpFrontendResponse",
+});
+export const DeleteIpLoadbalancingVrackNetworkRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/network/{vrackNetworkId}",
+    code: 200,
+}))).annotate({
+    identifier: "DeleteIpLoadbalancingVrackNetworkRequest",
+});
+export const DeleteIpLoadbalancingVrackNetworkResponse = 
+/*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteIpLoadbalancingVrackNetworkResponse",
+});
+export const GetIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "GET", uri: "/ipLoadbalancing/{serviceName}", code: 200 }))).annotate({
+    identifier: "GetIpLoadbalancingRequest",
+});
+export const IamResourceMetadataTagsMap = /*@__PURE__*/ S.Record(S.String, S.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",
+});
+export const IpLoadbalancingOrderableZone = /*@__PURE__*/ S.suspend(() => S.Struct({
+    name: S.optional(S.String),
+    planCode: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingOrderableZone",
+});
+export const IpLoadbalancingIpWithIAMOrderableZoneList = /*@__PURE__*/ S.Array(IpLoadbalancingOrderableZone);
+export const IpLoadbalancingSslConfigurationEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingIpStateEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingIpWithIAMZoneList = /*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingIpWithIAM = /*@__PURE__*/ S.suspend(() => S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    ipLoadbalancing: S.optional(S.String),
+    ipv4: S.optional(S.NullOr(S.String)),
+    ipv6: S.optional(S.NullOr(S.String)),
+    metricsToken: S.optional(S.NullOr(S.String)),
+    offer: S.optional(S.String),
+    orderableZone: S.optional(IpLoadbalancingIpWithIAMOrderableZoneList),
+    serviceName: S.optional(S.String),
+    sslConfiguration: S.optional(S.NullOr(IpLoadbalancingSslConfigurationEnum)),
+    state: S.optional(IpLoadbalancingIpStateEnum),
+    vrackEligibility: S.optional(S.Boolean),
+    vrackName: S.optional(S.NullOr(S.String)),
+    zone: S.optional(IpLoadbalancingIpWithIAMZoneList),
+})).annotate({
+    identifier: "IpLoadbalancingIpWithIAM",
+});
+export const GetIpLoadbalancingHttpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingHttpFarmRequest",
+});
+export const GetIpLoadbalancingHttpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingHttpFarmServerRequest",
+});
+export const GetIpLoadbalancingHttpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    transparentId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}/transparent/{transparentId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingHttpFarmServerTransparentRequest",
+});
+export const GetIpLoadbalancingHttpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingHttpFrontendRequest",
+});
+export const GetIpLoadbalancingHttpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingHttpRouteRequest",
+});
+export const GetIpLoadbalancingHttpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    ruleId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}/rule/{ruleId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingHttpRouteRuleRequest",
+});
+export const GetIpLoadbalancingLogKindRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/log/kind/{name}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingLogKindRequest",
+});
+export const IpLoadbalancingLdpKindLdpKindAdditionalReturnedFieldsList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingLdpKindLdpKind = /*@__PURE__*/ S.suspend(() => S.Struct({
+    additionalReturnedFields: S.optional(IpLoadbalancingLdpKindLdpKindAdditionalReturnedFieldsList),
+    createdAt: S.optional(S.String),
+    displayName: S.optional(S.String),
+    kindId: S.optional(S.String),
+    name: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingLdpKindLdpKind",
+});
+export const GetIpLoadbalancingLogSubscriptionRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    subscriptionId: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/log/subscription/{subscriptionId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingLogSubscriptionRequest",
+});
+export const IpLoadbalancingLogSubscriptionResource = /*@__PURE__*/ S.suspend(() => S.Struct({
+    name: S.optional(S.String),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingLogSubscriptionResource",
+});
+export const IpLoadbalancingLdpSubscriptionLdpSubscription = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    createdAt: S.optional(S.String),
+    kind: S.optional(S.String),
+    resource: S.optional(IpLoadbalancingLogSubscriptionResource),
+    serviceName: S.optional(S.String),
+    streamId: S.optional(S.String),
+    subscriptionId: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingLdpSubscriptionLdpSubscription",
+});
+export const GetIpLoadbalancingMetricsTokenRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/metricsToken",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingMetricsTokenRequest",
+});
+export const IpLoadbalancingMetricsToken = /*@__PURE__*/ S.suspend(() => S.Struct({
+    endpoint: S.optional(S.String),
+    token: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingMetricsToken",
+});
+export const GetIpLoadbalancingQuotaRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    zone: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/quota/{zone}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingQuotaRequest",
+});
+export const IpLoadbalancingQuotaQuota = /*@__PURE__*/ S.suspend(() => S.Struct({
+    alert: S.optional(S.NullOr(S.Number)),
+    included: S.optional(S.NullOr(S.Number)),
+    lastUpdateDate: S.optional(S.NullOr(S.String)),
+    resetDate: S.optional(S.NullOr(S.String)),
+    total: S.optional(S.NullOr(S.Number)),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingQuotaQuota",
+});
+export const GetIpLoadbalancingQuotaHistoryRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/quotaHistory/{id}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingQuotaHistoryRequest",
+});
+export const IpLoadbalancingQuotaHistoryQuotaHistory = /*@__PURE__*/ S.suspend(() => S.Struct({
+    historizedDate: S.optional(S.String),
+    id: S.optional(S.Number),
+    lastUpdateDate: S.optional(S.String),
+    resetDate: S.optional(S.String),
+    total: S.optional(S.Number),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingQuotaHistoryQuotaHistory",
+});
+export const GetIpLoadbalancingServiceInfosRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/serviceInfos",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingServiceInfosRequest",
+});
+export const ServicesServicePossibleRenewPeriodList = /*@__PURE__*/ S.Array(S.Number);
+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",
+});
+export const ServiceRenewalTypeEnum = /*@__PURE__*/ S.String;
+export const ServiceStateEnum = /*@__PURE__*/ S.String;
+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",
+});
+export const GetIpLoadbalancingSslRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/ssl/{id}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingSslRequest",
+});
+export const GetIpLoadbalancingStatusRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/status",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingStatusRequest",
+});
+export const IpLoadbalancingStatusComponentStatus = /*@__PURE__*/ S.suspend(() => S.Struct({
+    error: S.optional(S.Number),
+    ok: S.optional(S.Number),
+    unknown: S.optional(S.Number),
+    warn: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingStatusComponentStatus",
+});
+export const IpLoadbalancingStatusComponent = /*@__PURE__*/ S.suspend(() => S.Struct({
+    status: S.optional(IpLoadbalancingStatusComponentStatus),
+    total: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingStatusComponent",
+});
+export const IpLoadbalancingStatusEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingStatusService = /*@__PURE__*/ S.suspend(() => S.Struct({
+    status: S.optional(IpLoadbalancingStatusEnum),
+})).annotate({
+    identifier: "IpLoadbalancingStatusService",
+});
+export const IpLoadbalancingStatus = /*@__PURE__*/ S.suspend(() => S.Struct({
+    farms: S.optional(IpLoadbalancingStatusComponent),
+    frontends: S.optional(IpLoadbalancingStatusComponent),
+    servers: S.optional(IpLoadbalancingStatusComponent),
+    service: S.optional(IpLoadbalancingStatusService),
+})).annotate({
+    identifier: "IpLoadbalancingStatus",
+});
+export const GetIpLoadbalancingTaskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/task/{id}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTaskRequest",
+});
+export const GetIpLoadbalancingTcpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTcpFarmRequest",
+});
+export const GetIpLoadbalancingTcpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTcpFarmServerRequest",
+});
+export const GetIpLoadbalancingTcpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    transparentId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}/transparent/{transparentId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTcpFarmServerTransparentRequest",
+});
+export const GetIpLoadbalancingTcpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTcpFrontendRequest",
+});
+export const GetIpLoadbalancingTcpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTcpRouteRequest",
+});
+export const GetIpLoadbalancingTcpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    ruleId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}/rule/{ruleId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingTcpRouteRuleRequest",
+});
+export const GetIpLoadbalancingUdpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingUdpFarmRequest",
+});
+export const GetIpLoadbalancingUdpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingUdpFarmServerRequest",
+});
+export const GetIpLoadbalancingUdpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/udp/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingUdpFrontendRequest",
+});
+export const GetIpLoadbalancingVrackNetworkRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/network/{vrackNetworkId}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingVrackNetworkRequest",
+});
+export const GetIpLoadbalancingVrackNetworkCreationRulesRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/networkCreationRules",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingVrackNetworkCreationRulesRequest",
+});
+export const IpLoadbalancingVrackNetworkCreationRules = /*@__PURE__*/ S.suspend(() => S.Struct({
+    minNatIps: S.optional(S.Number),
+    remainingNetworks: S.optional(S.Number),
+    vrackName: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingVrackNetworkCreationRules",
+});
+export const GetIpLoadbalancingZoneRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/zone/{name}",
+    code: 200,
+}))).annotate({
+    identifier: "GetIpLoadbalancingZoneRequest",
+});
+export const IpLoadbalancingZoneZone = /*@__PURE__*/ S.suspend(() => S.Struct({
+    name: S.optional(S.String),
+    state: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingZoneZone",
+});
+export const IamResourceTagFilterInput = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "IamResourceTagFilterInput",
+});
+export const ListIpLoadbalancingRequestIamTagsValueList = /*@__PURE__*/ S.Array(IamResourceTagFilterInput);
+export const ListIpLoadbalancingRequestIamTagsMap = /*@__PURE__*/ S.Record(S.String, ListIpLoadbalancingRequestIamTagsValueList);
+export const ListIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    iamTags: S.optional(ListIpLoadbalancingRequestIamTagsMap.pipe(T.Query())),
+}).pipe(T.Http({ method: "GET", uri: "/ipLoadbalancing", code: 200 }))).annotate({
+    identifier: "ListIpLoadbalancingRequest",
+});
+export const ListIpLoadbalancingResponseBodyList = /*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingResponse",
+});
+export const ListIpLoadbalancingAvailableFarmProbesRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/availableFarmProbes",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingAvailableFarmProbesRequest",
+});
+export const IpLoadbalancingFarmAvailableProbeMatchesList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFarmAvailableProbeMethodList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFarmAvailableProbeNegatableMatchesList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingFarmAvailableProbe = /*@__PURE__*/ S.suspend(() => S.Struct({
+    matches: S.optional(IpLoadbalancingFarmAvailableProbeMatchesList),
+    method: S.optional(S.NullOr(IpLoadbalancingFarmAvailableProbeMethodList)),
+    negatableMatches: S.optional(IpLoadbalancingFarmAvailableProbeNegatableMatchesList),
+    port: S.optional(S.Boolean),
+    type: S.optional(S.String),
+    url: S.optional(S.Boolean),
+})).annotate({
+    identifier: "IpLoadbalancingFarmAvailableProbe",
+});
+export const ListIpLoadbalancingAvailableFarmProbesResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingFarmAvailableProbe);
+export const ListIpLoadbalancingAvailableFarmProbesResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingAvailableFarmProbesResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingAvailableFarmProbesResponse",
+});
+export const ListIpLoadbalancingAvailableFarmTypeRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/availableFarmType",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingAvailableFarmTypeRequest",
+});
+export const ListIpLoadbalancingAvailableFarmTypeResponseBodyList = 
+/*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingAvailableFarmTypeResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingAvailableFarmTypeResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingAvailableFarmTypeResponse",
+});
+export const ListIpLoadbalancingAvailableFrontendTypeRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/availableFrontendType",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingAvailableFrontendTypeRequest",
+});
+export const ListIpLoadbalancingAvailableFrontendTypeResponseBodyList = 
+/*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingAvailableFrontendTypeResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingAvailableFrontendTypeResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingAvailableFrontendTypeResponse",
+});
+export const ListIpLoadbalancingAvailableRouteActionsRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/availableRouteActions",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingAvailableRouteActionsRequest",
+});
+export const IpLoadbalancingRouteAvailableActionStatusList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const IpLoadbalancingRouteAvailableAction = /*@__PURE__*/ S.suspend(() => S.Struct({
+    destination: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+    status: S.optional(S.NullOr(IpLoadbalancingRouteAvailableActionStatusList)),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingRouteAvailableAction",
+});
+export const ListIpLoadbalancingAvailableRouteActionsResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingRouteAvailableAction);
+export const ListIpLoadbalancingAvailableRouteActionsResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingAvailableRouteActionsResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingAvailableRouteActionsResponse",
+});
+export const ListIpLoadbalancingAvailableRouteRulesRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/availableRouteRules",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingAvailableRouteRulesRequest",
+});
+export const IpLoadbalancingRouteAvailableRuleEnumList = /*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingRouteAvailableRuleMatchesList = 
+/*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingRouteAvailableRule = /*@__PURE__*/ S.suspend(() => S.Struct({
+    enum: S.optional(S.NullOr(IpLoadbalancingRouteAvailableRuleEnumList)),
+    hasSubField: S.optional(S.Boolean),
+    matches: S.optional(IpLoadbalancingRouteAvailableRuleMatchesList),
+    name: S.optional(S.String),
+    pattern: S.optional(S.String),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingRouteAvailableRule",
+});
+export const ListIpLoadbalancingAvailableRouteRulesResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingRouteAvailableRule);
+export const ListIpLoadbalancingAvailableRouteRulesResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingAvailableRouteRulesResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingAvailableRouteRulesResponse",
+});
+export const ListIpLoadbalancingDefinedFarmsRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.optional(S.Number.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/definedFarms",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingDefinedFarmsRequest",
+});
+export const ListIpLoadbalancingDefinedFarmsResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingDefinedFarm);
+export const ListIpLoadbalancingDefinedFarmsResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingDefinedFarmsResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingDefinedFarmsResponse",
+});
+export const ListIpLoadbalancingDefinedFrontendsRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/definedFrontends",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingDefinedFrontendsRequest",
+});
+export const IpLoadbalancingDefinedFrontend = IpLoadbalancingDefinedFarm;
+export const ListIpLoadbalancingDefinedFrontendsResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingDefinedFarm);
+export const ListIpLoadbalancingDefinedFrontendsResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingDefinedFrontendsResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingDefinedFrontendsResponse",
+});
+export const ListIpLoadbalancingDefinedRoutesRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/definedRoutes",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingDefinedRoutesRequest",
+});
+export const IpLoadbalancingDefinedRoute = /*@__PURE__*/ S.suspend(() => S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    routeId: S.optional(S.Number),
+    type: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingDefinedRoute",
+});
+export const ListIpLoadbalancingDefinedRoutesResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingDefinedRoute);
+export const ListIpLoadbalancingDefinedRoutesResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingDefinedRoutesResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingDefinedRoutesResponse",
+});
+export const ListIpLoadbalancingFailoverRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/failover",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingFailoverRequest",
+});
+export const ListIpLoadbalancingFailoverResponseBodyList = 
+/*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingFailoverResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingFailoverResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingFailoverResponse",
+});
+export const ListIpLoadbalancingHttpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.optional(S.Number.pipe(T.Query())),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingHttpFarmRequest",
+});
+export const ListIpLoadbalancingHttpFarmResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingHttpFarmResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingHttpFarmResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingHttpFarmResponse",
+});
+export const ListIpLoadbalancingHttpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    address: S.optional(S.String.pipe(T.Query())),
+    cookie: S.optional(S.String.pipe(T.Query())),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingHttpFarmServerRequest",
+});
+export const ListIpLoadbalancingHttpFarmServerResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingHttpFarmServerResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingHttpFarmServerResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingHttpFarmServerResponse",
+});
+export const ListIpLoadbalancingHttpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    slotId: S.optional(S.Number.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}/transparent",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingHttpFarmServerTransparentRequest",
+});
+export const ListIpLoadbalancingHttpFarmServerTransparentResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingHttpFarmServerTransparentResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingHttpFarmServerTransparentResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingHttpFarmServerTransparentResponse",
+});
+export const ListIpLoadbalancingHttpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    defaultFarmId: S.optional(S.Number.pipe(T.Query())),
+    defaultSslId: S.optional(S.Number.pipe(T.Query())),
+    port: S.optional(S.String.pipe(T.Query())),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/frontend",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingHttpFrontendRequest",
+});
+export const ListIpLoadbalancingHttpFrontendResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingHttpFrontendResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingHttpFrontendResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingHttpFrontendResponse",
+});
+export const ListIpLoadbalancingHttpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.optional(S.Number.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/route",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingHttpRouteRequest",
+});
+export const ListIpLoadbalancingHttpRouteResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingHttpRouteResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingHttpRouteResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingHttpRouteResponse",
+});
+export const ListIpLoadbalancingHttpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}/rule",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingHttpRouteRuleRequest",
+});
+export const ListIpLoadbalancingHttpRouteRuleResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingHttpRouteRuleResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingHttpRouteRuleResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingHttpRouteRuleResponse",
+});
+export const ListIpLoadbalancingLogKindRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/log/kind",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingLogKindRequest",
+});
+export const ListIpLoadbalancingLogKindResponseBodyList = /*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingLogKindResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingLogKindResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingLogKindResponse",
+});
+export const ListIpLoadbalancingLogSubscriptionRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    kind: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/log/subscription",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingLogSubscriptionRequest",
+});
+export const ListIpLoadbalancingLogSubscriptionResponseBodyList = 
+/*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingLogSubscriptionResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingLogSubscriptionResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingLogSubscriptionResponse",
+});
+export const ListIpLoadbalancingNatIpRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/natIp",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingNatIpRequest",
+});
+export const IpLoadbalancingNatIpsIpList = /*@__PURE__*/ S.Array(S.String);
+export const IpLoadbalancingNatIps = /*@__PURE__*/ S.suspend(() => S.Struct({
+    ip: S.optional(IpLoadbalancingNatIpsIpList),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingNatIps",
+});
+export const ListIpLoadbalancingNatIpResponseBodyList = /*@__PURE__*/ S.Array(IpLoadbalancingNatIps);
+export const ListIpLoadbalancingNatIpResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingNatIpResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingNatIpResponse",
+});
+export const ListIpLoadbalancingPendingChangesRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/pendingChanges",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingPendingChangesRequest",
+});
+export const IpLoadbalancingPendingChanges = /*@__PURE__*/ S.suspend(() => S.Struct({
+    number: S.optional(S.Number),
+    zone: S.optional(S.String),
+})).annotate({
+    identifier: "IpLoadbalancingPendingChanges",
+});
+export const ListIpLoadbalancingPendingChangesResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingPendingChanges);
+export const ListIpLoadbalancingPendingChangesResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingPendingChangesResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingPendingChangesResponse",
+});
+export const ListIpLoadbalancingQuotaRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/quota",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingQuotaRequest",
+});
+export const ListIpLoadbalancingQuotaResponseBodyList = /*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingQuotaResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingQuotaResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingQuotaResponse",
+});
+export const ListIpLoadbalancingQuotaHistoryRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    historizedDate_from: S.optional(S.String.pipe(T.Query("historizedDate.from"))),
+    historizedDate_to: S.optional(S.String.pipe(T.Query("historizedDate.to"))),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/quotaHistory",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingQuotaHistoryRequest",
+});
+export const ListIpLoadbalancingQuotaHistoryResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingQuotaHistoryResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingQuotaHistoryResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingQuotaHistoryResponse",
+});
+export const ListIpLoadbalancingSslRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    expireDate: S.optional(S.String.pipe(T.Query())),
+    fingerprint: S.optional(S.String.pipe(T.Query())),
+    serial: S.optional(S.String.pipe(T.Query())),
+    type: S.optional(IpLoadbalancingSslTypeEnum.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/ssl",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingSslRequest",
+});
+export const ListIpLoadbalancingSslResponseBodyList = /*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingSslResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingSslResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingSslResponse",
+});
+export const ListIpLoadbalancingTaskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    action: S.optional(IpLoadbalancingTaskActionEnum.pipe(T.Query())),
+    creationDate_from: S.optional(S.String.pipe(T.Query("creationDate.from"))),
+    creationDate_to: S.optional(S.String.pipe(T.Query("creationDate.to"))),
+    doneDate_from: S.optional(S.String.pipe(T.Query("doneDate.from"))),
+    doneDate_to: S.optional(S.String.pipe(T.Query("doneDate.to"))),
+    status: S.optional(IpLoadbalancingTaskStatusEnum.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/task",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTaskRequest",
+});
+export const ListIpLoadbalancingTaskResponseBodyList = /*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTaskResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTaskResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTaskResponse",
+});
+export const ListIpLoadbalancingTcpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.optional(S.Number.pipe(T.Query())),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTcpFarmRequest",
+});
+export const ListIpLoadbalancingTcpFarmResponseBodyList = /*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTcpFarmResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTcpFarmResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTcpFarmResponse",
+});
+export const ListIpLoadbalancingTcpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    address: S.optional(S.String.pipe(T.Query())),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTcpFarmServerRequest",
+});
+export const ListIpLoadbalancingTcpFarmServerResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTcpFarmServerResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTcpFarmServerResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTcpFarmServerResponse",
+});
+export const ListIpLoadbalancingTcpFarmServerTransparentRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    slotId: S.optional(S.Number.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}/transparent",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTcpFarmServerTransparentRequest",
+});
+export const ListIpLoadbalancingTcpFarmServerTransparentResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTcpFarmServerTransparentResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTcpFarmServerTransparentResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTcpFarmServerTransparentResponse",
+});
+export const ListIpLoadbalancingTcpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    defaultFarmId: S.optional(S.Number.pipe(T.Query())),
+    defaultSslId: S.optional(S.Number.pipe(T.Query())),
+    port: S.optional(S.String.pipe(T.Query())),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/frontend",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTcpFrontendRequest",
+});
+export const ListIpLoadbalancingTcpFrontendResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTcpFrontendResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTcpFrontendResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTcpFrontendResponse",
+});
+export const ListIpLoadbalancingTcpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.optional(S.Number.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTcpRouteRequest",
+});
+export const ListIpLoadbalancingTcpRouteResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTcpRouteResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTcpRouteResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTcpRouteResponse",
+});
+export const ListIpLoadbalancingTcpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}/rule",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingTcpRouteRuleRequest",
+});
+export const ListIpLoadbalancingTcpRouteRuleResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingTcpRouteRuleResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingTcpRouteRuleResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingTcpRouteRuleResponse",
+});
+export const ListIpLoadbalancingUdpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.optional(S.Number.pipe(T.Query())),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingUdpFarmRequest",
+});
+export const ListIpLoadbalancingUdpFarmResponseBodyList = /*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingUdpFarmResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingUdpFarmResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingUdpFarmResponse",
+});
+export const ListIpLoadbalancingUdpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    address: S.optional(S.String.pipe(T.Query())),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}/server",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingUdpFarmServerRequest",
+});
+export const ListIpLoadbalancingUdpFarmServerResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingUdpFarmServerResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingUdpFarmServerResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingUdpFarmServerResponse",
+});
+export const ListIpLoadbalancingUdpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    defaultFarmId: S.optional(S.Number.pipe(T.Query())),
+    port: S.optional(S.String.pipe(T.Query())),
+    zone: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/udp/frontend",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingUdpFrontendRequest",
+});
+export const ListIpLoadbalancingUdpFrontendResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingUdpFrontendResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingUdpFrontendResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingUdpFrontendResponse",
+});
+export const ListIpLoadbalancingVrackNetworkRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    subnet: S.optional(S.String.pipe(T.Query())),
+    vlan: S.optional(S.Number.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/network",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingVrackNetworkRequest",
+});
+export const ListIpLoadbalancingVrackNetworkResponseBodyList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const ListIpLoadbalancingVrackNetworkResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingVrackNetworkResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingVrackNetworkResponse",
+});
+export const ListIpLoadbalancingVrackStatusRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/status",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingVrackStatusRequest",
+});
+export const IpLoadbalancingVrackStateEnum = /*@__PURE__*/ S.String;
+export const IpLoadbalancingVrackInformationTaskList = /*@__PURE__*/ S.Array(S.Number);
+export const IpLoadbalancingVrackInformation = /*@__PURE__*/ S.suspend(() => S.Struct({
+    state: S.optional(IpLoadbalancingVrackStateEnum),
+    task: S.optional(IpLoadbalancingVrackInformationTaskList),
+    vrackName: S.optional(S.NullOr(S.String)),
+})).annotate({
+    identifier: "IpLoadbalancingVrackInformation",
+});
+export const ListIpLoadbalancingVrackTransparentGatewaysRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/transparent/gateways",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingVrackTransparentGatewaysRequest",
+});
+export const IpLoadbalancingVrackTransparentGateways = /*@__PURE__*/ S.suspend(() => S.Struct({
+    address: S.optional(S.String),
+    gateway: S.optional(S.String),
+    vlan: S.optional(S.Number),
+})).annotate({
+    identifier: "IpLoadbalancingVrackTransparentGateways",
+});
+export const ListIpLoadbalancingVrackTransparentGatewaysResponseBodyList = 
+/*@__PURE__*/ S.Array(IpLoadbalancingVrackTransparentGateways);
+export const ListIpLoadbalancingVrackTransparentGatewaysResponse = 
+/*@__PURE__*/ S.suspend(() => ListIpLoadbalancingVrackTransparentGatewaysResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingVrackTransparentGatewaysResponse",
+});
+export const ListIpLoadbalancingZoneRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "GET",
+    uri: "/ipLoadbalancing/{serviceName}/zone",
+    code: 200,
+}))).annotate({
+    identifier: "ListIpLoadbalancingZoneRequest",
+});
+export const ListIpLoadbalancingZoneResponseBodyList = /*@__PURE__*/ S.Array(S.String);
+export const ListIpLoadbalancingZoneResponse = /*@__PURE__*/ S.suspend(() => ListIpLoadbalancingZoneResponseBodyList.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ListIpLoadbalancingZoneResponse",
+});
+export const PutIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+    sslConfiguration: S.optional(S.NullOr(IpLoadbalancingSslConfigurationEnum)),
+}).pipe(T.Http({ method: "PUT", uri: "/ipLoadbalancing/{serviceName}", code: 200 }))).annotate({
+    identifier: "PutIpLoadbalancingRequest",
+});
+export const PutIpLoadbalancingResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingResponse",
+});
+export const PutIpLoadbalancingHttpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    balance: S.optional(S.NullOr(IpLoadbalancingBalanceHTTPEnum)),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.NullOr(IpLoadbalancingBackendProbe)),
+    stickiness: S.optional(S.NullOr(IpLoadbalancingStickinessHTTPEnum)),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingHttpFarmRequest",
+});
+export const PutIpLoadbalancingHttpFarmResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingHttpFarmResponse",
+});
+export const PutIpLoadbalancingHttpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    backup: S.optional(S.Boolean),
+    chain: S.optional(S.NullOr(S.String)),
+    cookie: S.optional(S.NullOr(S.String)),
+    displayName: S.optional(S.NullOr(S.String)),
+    onMarkedDown: S.optional(S.NullOr(IpLoadbalancingOnMarkedDownEnum)),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.Boolean),
+    proxyProtocolVersion: S.optional(S.NullOr(IpLoadbalancingProxyProtocolVersionEnum)),
+    ssl: S.optional(S.Boolean),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum),
+    weight: S.optional(S.NullOr(S.Number)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/http/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingHttpFarmServerRequest",
+});
+export const PutIpLoadbalancingHttpFarmServerResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingHttpFarmServerResponse",
+});
+export const PutIpLoadbalancingHttpFrontendRequestAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingHttpFrontendRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingHttpFrontendRequestDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingHttpFrontendRequestHttpHeaderList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingHttpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+    allowedSource: S.optional(S.NullOr(PutIpLoadbalancingHttpFrontendRequestAllowedSourceList)),
+    dedicatedIpfo: S.optional(S.NullOr(PutIpLoadbalancingHttpFrontendRequestDedicatedIpfoList)),
+    defaultFarmId: S.optional(S.NullOr(S.Number)),
+    defaultSslId: S.optional(S.NullOr(S.Number)),
+    deniedSource: S.optional(S.NullOr(PutIpLoadbalancingHttpFrontendRequestDeniedSourceList)),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    hsts: S.optional(S.Boolean),
+    httpHeader: S.optional(S.NullOr(PutIpLoadbalancingHttpFrontendRequestHttpHeaderList)),
+    port: S.optional(S.String),
+    redirectLocation: S.optional(S.NullOr(S.String)),
+    ssl: S.optional(S.Boolean),
+    zone: S.optional(S.String),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/http/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingHttpFrontendRequest",
+});
+export const PutIpLoadbalancingHttpFrontendResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingHttpFrontendResponse",
+});
+export const PutIpLoadbalancingHttpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    action: S.optional(IpLoadbalancingRouteHttpAction),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.NullOr(S.Number)),
+    weight: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingHttpRouteRequest",
+});
+export const PutIpLoadbalancingHttpRouteResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingHttpRouteResponse",
+});
+export const PutIpLoadbalancingHttpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    ruleId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+    field: S.optional(S.String),
+    match: S.optional(IpLoadbalancingRouteRuleMatchesEnum),
+    negate: S.optional(S.Boolean),
+    pattern: S.optional(S.NullOr(S.String)),
+    subField: S.optional(S.NullOr(S.String)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/http/route/{routeId}/rule/{ruleId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingHttpRouteRuleRequest",
+});
+export const PutIpLoadbalancingHttpRouteRuleResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingHttpRouteRuleResponse",
+});
+export const PutIpLoadbalancingQuotaRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    zone: S.String.pipe(T.Label()),
+    alert: S.optional(S.NullOr(S.Number)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/quota/{zone}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingQuotaRequest",
+});
+export const PutIpLoadbalancingQuotaResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingQuotaResponse",
+});
+export const PutIpLoadbalancingServiceInfosRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/serviceInfos",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingServiceInfosRequest",
+});
+export const PutIpLoadbalancingServiceInfosResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingServiceInfosResponse",
+});
+export const PutIpLoadbalancingSslRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/ssl/{id}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingSslRequest",
+});
+export const PutIpLoadbalancingSslResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingSslResponse",
+});
+export const PutIpLoadbalancingTcpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    balance: S.optional(S.NullOr(IpLoadbalancingBalanceTCPEnum)),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.NullOr(IpLoadbalancingBackendProbe)),
+    stickiness: S.optional(S.NullOr(IpLoadbalancingStickinessTCPEnum)),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingTcpFarmRequest",
+});
+export const PutIpLoadbalancingTcpFarmResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingTcpFarmResponse",
+});
+export const PutIpLoadbalancingTcpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    backup: S.optional(S.Boolean),
+    chain: S.optional(S.NullOr(S.String)),
+    displayName: S.optional(S.NullOr(S.String)),
+    onMarkedDown: S.optional(S.NullOr(IpLoadbalancingOnMarkedDownEnum)),
+    port: S.optional(S.NullOr(S.Number)),
+    probe: S.optional(S.Boolean),
+    proxyProtocolVersion: S.optional(S.NullOr(IpLoadbalancingProxyProtocolVersionEnum)),
+    ssl: S.optional(S.Boolean),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum),
+    weight: S.optional(S.NullOr(S.Number)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingTcpFarmServerRequest",
+});
+export const PutIpLoadbalancingTcpFarmServerResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingTcpFarmServerResponse",
+});
+export const PutIpLoadbalancingTcpFrontendRequestAllowedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingTcpFrontendRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingTcpFrontendRequestDeniedSourceList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingTcpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+    allowedSource: S.optional(S.NullOr(PutIpLoadbalancingTcpFrontendRequestAllowedSourceList)),
+    dedicatedIpfo: S.optional(S.NullOr(PutIpLoadbalancingTcpFrontendRequestDedicatedIpfoList)),
+    defaultFarmId: S.optional(S.NullOr(S.Number)),
+    defaultSslId: S.optional(S.NullOr(S.Number)),
+    deniedSource: S.optional(S.NullOr(PutIpLoadbalancingTcpFrontendRequestDeniedSourceList)),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.String),
+    ssl: S.optional(S.Boolean),
+    zone: S.optional(S.String),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingTcpFrontendRequest",
+});
+export const PutIpLoadbalancingTcpFrontendResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingTcpFrontendResponse",
+});
+export const PutIpLoadbalancingTcpRouteRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    action: S.optional(IpLoadbalancingRouteTcpAction),
+    displayName: S.optional(S.NullOr(S.String)),
+    frontendId: S.optional(S.NullOr(S.Number)),
+    weight: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingTcpRouteRequest",
+});
+export const PutIpLoadbalancingTcpRouteResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingTcpRouteResponse",
+});
+export const PutIpLoadbalancingTcpRouteRuleRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    routeId: S.Number.pipe(T.Label()),
+    ruleId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+    field: S.optional(S.String),
+    match: S.optional(IpLoadbalancingRouteRuleMatchesEnum),
+    negate: S.optional(S.Boolean),
+    pattern: S.optional(S.NullOr(S.String)),
+    subField: S.optional(S.NullOr(S.String)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/tcp/route/{routeId}/rule/{ruleId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingTcpRouteRuleRequest",
+});
+export const PutIpLoadbalancingTcpRouteRuleResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingTcpRouteRuleResponse",
+});
+export const PutIpLoadbalancingUdpFarmRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.Number),
+    vrackNetworkId: S.optional(S.NullOr(S.Number)),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingUdpFarmRequest",
+});
+export const PutIpLoadbalancingUdpFarmResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingUdpFarmResponse",
+});
+export const PutIpLoadbalancingUdpFarmServerRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    farmId: S.Number.pipe(T.Label()),
+    serverId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.NullOr(S.Number)),
+    status: S.optional(IpLoadbalancingBackendCustomerServerStatusEnum),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/udp/farm/{farmId}/server/{serverId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingUdpFarmServerRequest",
+});
+export const PutIpLoadbalancingUdpFarmServerResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingUdpFarmServerResponse",
+});
+export const PutIpLoadbalancingUdpFrontendRequestDedicatedIpfoList = 
+/*@__PURE__*/ S.Array(S.String);
+export const PutIpLoadbalancingUdpFrontendRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    frontendId: S.Number.pipe(T.Label()),
+    dedicatedIpfo: S.optional(S.NullOr(PutIpLoadbalancingUdpFrontendRequestDedicatedIpfoList)),
+    defaultFarmId: S.optional(S.NullOr(S.Number)),
+    disabled: S.optional(S.Boolean),
+    displayName: S.optional(S.NullOr(S.String)),
+    port: S.optional(S.String),
+    zone: S.optional(S.String),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/udp/frontend/{frontendId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingUdpFrontendRequest",
+});
+export const PutIpLoadbalancingUdpFrontendResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingUdpFrontendResponse",
+});
+export const PutIpLoadbalancingVrackNetworkRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.Number.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+    natIp: S.optional(S.String),
+    vlan: S.optional(S.Number),
+}).pipe(T.Http({
+    method: "PUT",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/network/{vrackNetworkId}",
+    code: 200,
+}))).annotate({
+    identifier: "PutIpLoadbalancingVrackNetworkRequest",
+});
+export const PutIpLoadbalancingVrackNetworkResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutIpLoadbalancingVrackNetworkResponse",
+});
+export const RefreshIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    zone: S.optional(S.String),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/refresh",
+    code: 200,
+}))).annotate({
+    identifier: "RefreshIpLoadbalancingRequest",
+});
+export const TerminateIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/terminate",
+    code: 200,
+}))).annotate({
+    identifier: "TerminateIpLoadbalancingRequest",
+});
+export const TerminateIpLoadbalancingResponse = /*@__PURE__*/ S.suspend(() => S.String.pipe(T.RawResponseRoot())).annotate({
+    identifier: "TerminateIpLoadbalancingResponse",
+});
+export const TerminateIpLoadbalancingZoneRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/zone/{name}/terminate",
+    code: 200,
+}))).annotate({
+    identifier: "TerminateIpLoadbalancingZoneRequest",
+});
+export const TerminateIpLoadbalancingZoneResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "TerminateIpLoadbalancingZoneResponse",
+});
+export const UpdateIpLoadbalancingVrackNetworkFarmIdRequestFarmIdList = 
+/*@__PURE__*/ S.Array(S.Number);
+export const UpdateIpLoadbalancingVrackNetworkFarmIdRequest = 
+/*@__PURE__*/ S.suspend(() => S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackNetworkId: S.Number.pipe(T.Label()),
+    farmId: UpdateIpLoadbalancingVrackNetworkFarmIdRequestFarmIdList,
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/ipLoadbalancing/{serviceName}/vrack/network/{vrackNetworkId}/updateFarmId",
+    code: 200,
+}))).annotate({
+    identifier: "UpdateIpLoadbalancingVrackNetworkFarmIdRequest",
+});
+/** Cancel the termination request of your service zone option */
+export const cancelIpLoadbalancingZoneTermination = /*@__PURE__*/ API.make(() => ({
+    input: CancelIpLoadbalancingZoneTerminationRequest,
+    output: CancelIpLoadbalancingZoneTerminationResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Confirm service termination */
+export const confirmIpLoadbalancingTermination = /*@__PURE__*/ API.make(() => ({
+    input: ConfirmIpLoadbalancingTerminationRequest,
+    output: ConfirmIpLoadbalancingTerminationResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Launch a contact change procedure */
+export const createIpLoadbalancingChangeContact = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingChangeContactRequest,
+    output: CreateIpLoadbalancingChangeContactResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Order a free certificate. We order and deliver it for you */
+export const createIpLoadbalancingFreeCertificate = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingFreeCertificateRequest,
+    output: IpLoadbalancingTaskTask,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new HTTP Farm on your IP Load Balancing */
+export const createIpLoadbalancingHttpFarm = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpFarmRequest,
+    output: IpLoadbalancingBackendHttpBackendHttp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a server to an HTTP Farm */
+export const createIpLoadbalancingHttpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpFarmServerRequest,
+    output: IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new vrack transparent ip */
+export const createIpLoadbalancingHttpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpFarmServerTransparentRequest,
+    output: IpLoadbalancingVrackTransparentIpVrackTransparentIp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new http frontend on your IP Load Balancing */
+export const createIpLoadbalancingHttpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpFrontendRequest,
+    output: IpLoadbalancingFrontendHttpFrontendHttp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Move the frontend in or out vrack */
+export const createIpLoadbalancingHttpFrontendPrivate = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpFrontendPrivateRequest,
+    output: IpLoadbalancingFrontendFrontend,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new HTTP route to your frontend */
+export const createIpLoadbalancingHttpRoute = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpRouteRequest,
+    output: IpLoadbalancingRouteHttpRouteHttp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new rule to your route */
+export const createIpLoadbalancingHttpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingHttpRouteRuleRequest,
+    output: IpLoadbalancingRouteRuleRouteRule,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Create a log subscription for your Load Balancer */
+export const createIpLoadbalancingLogSubscription = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingLogSubscriptionRequest,
+    output: IpLoadbalancingLogSubscriptionResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Generate a log url */
+export const createIpLoadbalancingLogUrl = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingLogUrlRequest,
+    output: IpLoadbalancingLogUrl,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new custom SSL certificate on your IP Load Balancing */
+export const createIpLoadbalancingSsl = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingSslRequest,
+    output: IpLoadbalancingSslSsl,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new TCP Farm on your IP Load Balancing */
+export const createIpLoadbalancingTcpFarm = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpFarmRequest,
+    output: IpLoadbalancingBackendTcpBackendTcp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a server to a TCP Farm */
+export const createIpLoadbalancingTcpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpFarmServerRequest,
+    output: IpLoadbalancingBackendTcpCustomerServerBackendTCPServer,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new vrack transparent ip */
+export const createIpLoadbalancingTcpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpFarmServerTransparentRequest,
+    output: IpLoadbalancingVrackTransparentIpVrackTransparentIp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new TCP frontend on your IP Load Balancing */
+export const createIpLoadbalancingTcpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpFrontendRequest,
+    output: IpLoadbalancingFrontendTcpFrontendTcp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Move the frontend in or out vrack */
+export const createIpLoadbalancingTcpFrontendPrivate = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpFrontendPrivateRequest,
+    output: IpLoadbalancingFrontendFrontend,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new TCP route to your frontend */
+export const createIpLoadbalancingTcpRoute = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpRouteRequest,
+    output: IpLoadbalancingRouteTcpRouteTcp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new rule to your route */
+export const createIpLoadbalancingTcpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingTcpRouteRuleRequest,
+    output: IpLoadbalancingRouteRuleRouteRule,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new UDP Farm on your IP Load Balancing */
+export const createIpLoadbalancingUdpFarm = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingUdpFarmRequest,
+    output: IpLoadbalancingBackendUdpBackendUdp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a server to an UDP Farm */
+export const createIpLoadbalancingUdpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingUdpFarmServerRequest,
+    output: IpLoadbalancingBackendUdpCustomerServerBackendUDPServer,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a new UDP frontend on your IP Load Balancing */
+export const createIpLoadbalancingUdpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingUdpFrontendRequest,
+    output: IpLoadbalancingFrontendUdpFrontendUdp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Add a description of a private network in the attached vRack */
+export const createIpLoadbalancingVrackNetwork = /*@__PURE__*/ API.make(() => ({
+    input: CreateIpLoadbalancingVrackNetworkRequest,
+    output: IpLoadbalancingVrackNetworkVrackNetwork,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete an HTTP Farm */
+export const deleteIpLoadbalancingHttpFarm = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingHttpFarmRequest,
+    output: DeleteIpLoadbalancingHttpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a server from an HTTP Farm */
+export const deleteIpLoadbalancingHttpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingHttpFarmServerRequest,
+    output: DeleteIpLoadbalancingHttpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a vrack transparent ip */
+export const deleteIpLoadbalancingHttpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingHttpFarmServerTransparentRequest,
+    output: DeleteIpLoadbalancingHttpFarmServerTransparentResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete an HTTP frontend */
+export const deleteIpLoadbalancingHttpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingHttpFrontendRequest,
+    output: DeleteIpLoadbalancingHttpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete this HTTP route */
+export const deleteIpLoadbalancingHttpRoute = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingHttpRouteRequest,
+    output: DeleteIpLoadbalancingHttpRouteResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete this rule from the route */
+export const deleteIpLoadbalancingHttpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingHttpRouteRuleRequest,
+    output: DeleteIpLoadbalancingHttpRouteRuleResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a log subscription for your Load Balancer */
+export const deleteIpLoadbalancingLogSubscription = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingLogSubscriptionRequest,
+    output: IpLoadbalancingLogSubscriptionResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a custom SSL certificate */
+export const deleteIpLoadbalancingSsl = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingSslRequest,
+    output: DeleteIpLoadbalancingSslResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a TCP Farm */
+export const deleteIpLoadbalancingTcpFarm = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingTcpFarmRequest,
+    output: DeleteIpLoadbalancingTcpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a server from a TCP Farm */
+export const deleteIpLoadbalancingTcpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingTcpFarmServerRequest,
+    output: DeleteIpLoadbalancingTcpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a vrack transparent ip */
+export const deleteIpLoadbalancingTcpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingTcpFarmServerTransparentRequest,
+    output: DeleteIpLoadbalancingTcpFarmServerTransparentResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete an TCP frontend */
+export const deleteIpLoadbalancingTcpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingTcpFrontendRequest,
+    output: DeleteIpLoadbalancingTcpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete this TCP route */
+export const deleteIpLoadbalancingTcpRoute = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingTcpRouteRequest,
+    output: DeleteIpLoadbalancingTcpRouteResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete this rule from the route */
+export const deleteIpLoadbalancingTcpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingTcpRouteRuleRequest,
+    output: DeleteIpLoadbalancingTcpRouteRuleResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete an UDP Farm */
+export const deleteIpLoadbalancingUdpFarm = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingUdpFarmRequest,
+    output: DeleteIpLoadbalancingUdpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a server from an UDP Farm */
+export const deleteIpLoadbalancingUdpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingUdpFarmServerRequest,
+    output: DeleteIpLoadbalancingUdpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete an UDP frontend */
+export const deleteIpLoadbalancingUdpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingUdpFrontendRequest,
+    output: DeleteIpLoadbalancingUdpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete this description of a private network in the vRack. It must not be used by any farm server */
+export const deleteIpLoadbalancingVrackNetwork = /*@__PURE__*/ API.make(() => ({
+    input: DeleteIpLoadbalancingVrackNetworkRequest,
+    output: DeleteIpLoadbalancingVrackNetworkResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancing = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingRequest,
+    output: IpLoadbalancingIpWithIAM,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingHttpFarm = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingHttpFarmRequest,
+    output: IpLoadbalancingBackendHttpBackendHttp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingHttpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingHttpFarmServerRequest,
+    output: IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingHttpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingHttpFarmServerTransparentRequest,
+    output: IpLoadbalancingVrackTransparentIpVrackTransparentIp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingHttpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingHttpFrontendRequest,
+    output: IpLoadbalancingFrontendHttpFrontendHttp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingHttpRoute = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingHttpRouteRequest,
+    output: IpLoadbalancingRouteHttpRouteHttp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingHttpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingHttpRouteRuleRequest,
+    output: IpLoadbalancingRouteRuleRouteRule,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingLogKind = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingLogKindRequest,
+    output: IpLoadbalancingLdpKindLdpKind,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingLogSubscription = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingLogSubscriptionRequest,
+    output: IpLoadbalancingLdpSubscriptionLdpSubscription,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Retrieve metrics token and endpoint for your Load Balancer */
+export const getIpLoadbalancingMetricsToken = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingMetricsTokenRequest,
+    output: IpLoadbalancingMetricsToken,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingQuota = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingQuotaRequest,
+    output: IpLoadbalancingQuotaQuota,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingQuotaHistory = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingQuotaHistoryRequest,
+    output: IpLoadbalancingQuotaHistoryQuotaHistory,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get service information */
+export const getIpLoadbalancingServiceInfos = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingServiceInfosRequest,
+    output: ServicesService,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingSsl = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingSslRequest,
+    output: IpLoadbalancingSslSsl,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get the global status of your IPLB */
+export const getIpLoadbalancingStatus = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingStatusRequest,
+    output: IpLoadbalancingStatus,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTask = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTaskRequest,
+    output: IpLoadbalancingTaskTask,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTcpFarm = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTcpFarmRequest,
+    output: IpLoadbalancingBackendTcpBackendTcp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTcpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTcpFarmServerRequest,
+    output: IpLoadbalancingBackendTcpCustomerServerBackendTCPServer,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTcpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTcpFarmServerTransparentRequest,
+    output: IpLoadbalancingVrackTransparentIpVrackTransparentIp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTcpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTcpFrontendRequest,
+    output: IpLoadbalancingFrontendTcpFrontendTcp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTcpRoute = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTcpRouteRequest,
+    output: IpLoadbalancingRouteTcpRouteTcp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingTcpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingTcpRouteRuleRequest,
+    output: IpLoadbalancingRouteRuleRouteRule,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingUdpFarm = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingUdpFarmRequest,
+    output: IpLoadbalancingBackendUdpBackendUdp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingUdpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingUdpFarmServerRequest,
+    output: IpLoadbalancingBackendUdpCustomerServerBackendUDPServer,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingUdpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingUdpFrontendRequest,
+    output: IpLoadbalancingFrontendUdpFrontendUdp,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingVrackNetwork = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingVrackNetworkRequest,
+    output: IpLoadbalancingVrackNetworkVrackNetwork,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Rules to create a network attached to a vrack */
+export const getIpLoadbalancingVrackNetworkCreationRules = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingVrackNetworkCreationRulesRequest,
+    output: IpLoadbalancingVrackNetworkCreationRules,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get this object properties */
+export const getIpLoadbalancingZone = /*@__PURE__*/ API.make(() => ({
+    input: GetIpLoadbalancingZoneRequest,
+    output: IpLoadbalancingZoneZone,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** List of your load balancing IP */
+export const listIpLoadbalancing = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingRequest,
+    output: ListIpLoadbalancingResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Available farm probes for health checks */
+export const listIpLoadbalancingAvailableFarmProbes = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingAvailableFarmProbesRequest,
+    output: ListIpLoadbalancingAvailableFarmProbesResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Available farm types */
+export const listIpLoadbalancingAvailableFarmType = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingAvailableFarmTypeRequest,
+    output: ListIpLoadbalancingAvailableFarmTypeResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Available frontend type */
+export const listIpLoadbalancingAvailableFrontendType = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingAvailableFrontendTypeRequest,
+    output: ListIpLoadbalancingAvailableFrontendTypeResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Available route actions */
+export const listIpLoadbalancingAvailableRouteActions = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingAvailableRouteActionsRequest,
+    output: ListIpLoadbalancingAvailableRouteActionsResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Available route match rules */
+export const listIpLoadbalancingAvailableRouteRules = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingAvailableRouteRulesRequest,
+    output: ListIpLoadbalancingAvailableRouteRulesResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** List of defined farms, and whether they are HTTP, TCP or UDP */
+export const listIpLoadbalancingDefinedFarms = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingDefinedFarmsRequest,
+    output: ListIpLoadbalancingDefinedFarmsResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** List of defined frontends, and whether they are HTTP, TCP or UDP */
+export const listIpLoadbalancingDefinedFrontends = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingDefinedFrontendsRequest,
+    output: ListIpLoadbalancingDefinedFrontendsResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** List of defined routes, and whether they are HTTP or TCP */
+export const listIpLoadbalancingDefinedRoutes = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingDefinedRoutesRequest,
+    output: ListIpLoadbalancingDefinedRoutesResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** List all failover ip routed to this IPLB */
+export const listIpLoadbalancingFailover = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingFailoverRequest,
+    output: ListIpLoadbalancingFailoverResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP Farm for this iplb */
+export const listIpLoadbalancingHttpFarm = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingHttpFarmRequest,
+    output: ListIpLoadbalancingHttpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP Farm's Servers */
+export const listIpLoadbalancingHttpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingHttpFarmServerRequest,
+    output: ListIpLoadbalancingHttpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP Farm's Servers transparent configuration */
+export const listIpLoadbalancingHttpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingHttpFarmServerTransparentRequest,
+    output: ListIpLoadbalancingHttpFarmServerTransparentResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP frontends for this iplb */
+export const listIpLoadbalancingHttpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingHttpFrontendRequest,
+    output: ListIpLoadbalancingHttpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP routes for this iplb */
+export const listIpLoadbalancingHttpRoute = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingHttpRouteRequest,
+    output: ListIpLoadbalancingHttpRouteResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP routes for this iplb */
+export const listIpLoadbalancingHttpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingHttpRouteRuleRequest,
+    output: ListIpLoadbalancingHttpRouteRuleResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Log kinds for your Load Balancer */
+export const listIpLoadbalancingLogKind = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingLogKindRequest,
+    output: ListIpLoadbalancingLogKindResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Log subscriptions for your Load Balancer */
+export const listIpLoadbalancingLogSubscription = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingLogSubscriptionRequest,
+    output: ListIpLoadbalancingLogSubscriptionResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Ip subnet used by OVH to nat requests on your IPLB to your backends Ip subnet used by OVH to nat requests on your IPLB to your backends. You must ensure that your backends are not part of a network that overlap with this one */
+export const listIpLoadbalancingNatIp = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingNatIpRequest,
+    output: ListIpLoadbalancingNatIpResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** List the pending changes on your Load Balancer configuration, per zone */
+export const listIpLoadbalancingPendingChanges = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingPendingChangesRequest,
+    output: ListIpLoadbalancingPendingChangesResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Available quota informations for current billing period per zone */
+export const listIpLoadbalancingQuota = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingQuotaRequest,
+    output: ListIpLoadbalancingQuotaResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Quota history informations, per month */
+export const listIpLoadbalancingQuotaHistory = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingQuotaHistoryRequest,
+    output: ListIpLoadbalancingQuotaHistoryResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Ssl for this iplb */
+export const listIpLoadbalancingSsl = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingSslRequest,
+    output: ListIpLoadbalancingSslResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Task for this iplb */
+export const listIpLoadbalancingTask = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTaskRequest,
+    output: ListIpLoadbalancingTaskResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** TCP Farm for this iplb */
+export const listIpLoadbalancingTcpFarm = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTcpFarmRequest,
+    output: ListIpLoadbalancingTcpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** TCP Farm's Servers */
+export const listIpLoadbalancingTcpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTcpFarmServerRequest,
+    output: ListIpLoadbalancingTcpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** TCP Farm's Servers transparent configuration */
+export const listIpLoadbalancingTcpFarmServerTransparent = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTcpFarmServerTransparentRequest,
+    output: ListIpLoadbalancingTcpFarmServerTransparentResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** TCP frontends for this iplb */
+export const listIpLoadbalancingTcpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTcpFrontendRequest,
+    output: ListIpLoadbalancingTcpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** TCP routes for this iplb */
+export const listIpLoadbalancingTcpRoute = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTcpRouteRequest,
+    output: ListIpLoadbalancingTcpRouteResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** HTTP routes for this iplb */
+export const listIpLoadbalancingTcpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingTcpRouteRuleRequest,
+    output: ListIpLoadbalancingTcpRouteRuleResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** UDP Farm for this iplb */
+export const listIpLoadbalancingUdpFarm = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingUdpFarmRequest,
+    output: ListIpLoadbalancingUdpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** UDP Farm's Servers */
+export const listIpLoadbalancingUdpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingUdpFarmServerRequest,
+    output: ListIpLoadbalancingUdpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** UDP frontends for this iplb */
+export const listIpLoadbalancingUdpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingUdpFrontendRequest,
+    output: ListIpLoadbalancingUdpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Descriptions of private networks in the vRack attached to this Load Balancer */
+export const listIpLoadbalancingVrackNetwork = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingVrackNetworkRequest,
+    output: ListIpLoadbalancingVrackNetworkResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Information about vRack for your Load Balancer */
+export const listIpLoadbalancingVrackStatus = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingVrackStatusRequest,
+    output: IpLoadbalancingVrackInformation,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Get gateways for configured vrack transparent ip */
+export const listIpLoadbalancingVrackTransparentGateways = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingVrackTransparentGatewaysRequest,
+    output: ListIpLoadbalancingVrackTransparentGatewaysResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Zone for this iplb */
+export const listIpLoadbalancingZone = /*@__PURE__*/ API.make(() => ({
+    input: ListIpLoadbalancingZoneRequest,
+    output: ListIpLoadbalancingZoneResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancing = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingRequest,
+    output: PutIpLoadbalancingResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingHttpFarm = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingHttpFarmRequest,
+    output: PutIpLoadbalancingHttpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingHttpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingHttpFarmServerRequest,
+    output: PutIpLoadbalancingHttpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingHttpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingHttpFrontendRequest,
+    output: PutIpLoadbalancingHttpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingHttpRoute = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingHttpRouteRequest,
+    output: PutIpLoadbalancingHttpRouteResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingHttpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingHttpRouteRuleRequest,
+    output: PutIpLoadbalancingHttpRouteRuleResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingQuota = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingQuotaRequest,
+    output: PutIpLoadbalancingQuotaResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Update service information */
+export const putIpLoadbalancingServiceInfos = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingServiceInfosRequest,
+    output: PutIpLoadbalancingServiceInfosResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingSsl = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingSslRequest,
+    output: PutIpLoadbalancingSslResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingTcpFarm = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingTcpFarmRequest,
+    output: PutIpLoadbalancingTcpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingTcpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingTcpFarmServerRequest,
+    output: PutIpLoadbalancingTcpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingTcpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingTcpFrontendRequest,
+    output: PutIpLoadbalancingTcpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingTcpRoute = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingTcpRouteRequest,
+    output: PutIpLoadbalancingTcpRouteResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingTcpRouteRule = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingTcpRouteRuleRequest,
+    output: PutIpLoadbalancingTcpRouteRuleResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingUdpFarm = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingUdpFarmRequest,
+    output: PutIpLoadbalancingUdpFarmResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingUdpFarmServer = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingUdpFarmServerRequest,
+    output: PutIpLoadbalancingUdpFarmServerResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingUdpFrontend = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingUdpFrontendRequest,
+    output: PutIpLoadbalancingUdpFrontendResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Alter this object properties */
+export const putIpLoadbalancingVrackNetwork = /*@__PURE__*/ API.make(() => ({
+    input: PutIpLoadbalancingVrackNetworkRequest,
+    output: PutIpLoadbalancingVrackNetworkResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Apply the configuration to your iplb */
+export const refreshIpLoadbalancing = /*@__PURE__*/ API.make(() => ({
+    input: RefreshIpLoadbalancingRequest,
+    output: IpLoadbalancingTaskTask,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 terminateIpLoadbalancing = /*@__PURE__*/ API.make(() => ({
+    input: TerminateIpLoadbalancingRequest,
+    output: TerminateIpLoadbalancingResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Terminate your service zone option */
+export const terminateIpLoadbalancingZone = /*@__PURE__*/ API.make(() => ({
+    input: TerminateIpLoadbalancingZoneRequest,
+    output: TerminateIpLoadbalancingZoneResponse,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+/** Update farm attached to that vrack network id */
+export const updateIpLoadbalancingVrackNetworkFarmId = /*@__PURE__*/ API.make(() => ({
+    input: UpdateIpLoadbalancingVrackNetworkFarmIdRequest,
+    output: IpLoadbalancingVrackNetworkVrackNetwork,
+    errors: [UnknownOvhError],
+    protocol: OvhProtocol,
+    retry: Retry.Retry,
+}));
+//# sourceMappingURL=iploadbalancing.js.map