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

package/lib/services/iploadbalancing.d.ts

@@ -0,0 +1,3059 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type OvhOpError, type OvhOpContext } from "../protocol.ts";
+export type { OvhOpError, OvhOpContext };
+export interface CancelIpLoadbalancingZoneTerminationRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Name of your zone */
+    name: string;
+}
+export declare const CancelIpLoadbalancingZoneTerminationRequest: S.Schema<CancelIpLoadbalancingZoneTerminationRequest>;
+export interface CancelIpLoadbalancingZoneTerminationResponse {
+}
+export declare const CancelIpLoadbalancingZoneTerminationResponse: S.Schema<CancelIpLoadbalancingZoneTerminationResponse>;
+/** All future uses you can provide for a service termination */
+export type ServiceTerminationFutureUseEnum = "NOT_REPLACING_SERVICE" | "OTHER" | "SUBSCRIBE_AN_OTHER_SERVICE" | "SUBSCRIBE_OTHER_KIND_OF_SERVICE_WITH_COMPETITOR" | "SUBSCRIBE_SIMILAR_SERVICE_WITH_COMPETITOR";
+export declare const ServiceTerminationFutureUseEnum: any;
+/** All reasons you can provide for a service termination */
+export type ServiceTerminationReasonEnum = "FEATURES_DONT_SUIT_ME" | "LACK_OF_PERFORMANCES" | "MIGRATED_TO_ANOTHER_OVH_PRODUCT" | "MIGRATED_TO_COMPETITOR" | "NOT_ENOUGH_RECOGNITION" | "NOT_NEEDED_ANYMORE" | "NOT_RELIABLE" | "NO_ANSWER" | "OTHER" | "PRODUCT_DIMENSION_DONT_SUIT_ME" | "PRODUCT_TOOLS_DONT_SUIT_ME" | "TOO_EXPENSIVE" | "TOO_HARD_TO_USE" | "UNSATIFIED_BY_CUSTOMER_SUPPORT";
+export declare const ServiceTerminationReasonEnum: any;
+export interface ConfirmIpLoadbalancingTerminationRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Commentary about your termination request */
+    commentary?: string;
+    /** What next after your termination request */
+    futureUse?: ServiceTerminationFutureUseEnum | (string & {});
+    /** Reason of your termination request */
+    reason?: ServiceTerminationReasonEnum | (string & {});
+    /** The termination token sent by email to the admin contact */
+    token: string;
+}
+export declare const ConfirmIpLoadbalancingTerminationRequest: S.Schema<ConfirmIpLoadbalancingTerminationRequest>;
+export type ConfirmIpLoadbalancingTerminationResponse = string;
+export declare const ConfirmIpLoadbalancingTerminationResponse: S.Schema<ConfirmIpLoadbalancingTerminationResponse>;
+export interface CreateIpLoadbalancingChangeContactRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** The contact to set as admin contact */
+    contactAdmin?: string;
+    /** The contact to set as billing contact */
+    contactBilling?: string;
+    /** The contact to set as tech contact */
+    contactTech?: string;
+}
+export declare const CreateIpLoadbalancingChangeContactRequest: S.Schema<CreateIpLoadbalancingChangeContactRequest>;
+export type CreateIpLoadbalancingChangeContactResponseBodyList = Array<number>;
+export declare const CreateIpLoadbalancingChangeContactResponseBodyList: S.Schema<CreateIpLoadbalancingChangeContactResponseBodyList>;
+export type CreateIpLoadbalancingChangeContactResponse = CreateIpLoadbalancingChangeContactResponseBodyList;
+export declare const CreateIpLoadbalancingChangeContactResponse: S.Schema<CreateIpLoadbalancingChangeContactResponse>;
+/** The FQDN for which you want a free certificate. A DCV (Domain Control Validation) http request will be made to http://your_domain.abc, make sure this domain exists and resolves to your iplb ip before ordering */
+export type CreateIpLoadbalancingFreeCertificateRequestFqdnList = Array<string>;
+export declare const CreateIpLoadbalancingFreeCertificateRequestFqdnList: S.Schema<CreateIpLoadbalancingFreeCertificateRequestFqdnList>;
+export interface CreateIpLoadbalancingFreeCertificateRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** The FQDN for which you want a free certificate. A DCV (Domain Control Validation) http request will be made to http://your_domain.abc, make sure this domain exists and resolves to your iplb ip before ordering */
+    fqdn: CreateIpLoadbalancingFreeCertificateRequestFqdnList;
+}
+export declare const CreateIpLoadbalancingFreeCertificateRequest: S.Schema<CreateIpLoadbalancingFreeCertificateRequest>;
+/** Possible task action */
+export type IpLoadbalancingTaskActionEnum = "deleteIplb" | "deployIplb" | "install" | "installIplb" | "installZone" | "orderFreeCertificate" | "orderPaidCertificate" | "orderSsl" | "refreshIplb" | "releaseIplb" | "releaseIplbZone" | "reopenIplb" | "suspendIplb" | "suspendZone" | "switchToIplbNextGenerationApi" | "vrackAttach" | "vrackDetach";
+export declare const IpLoadbalancingTaskActionEnum: any;
+/** Possible task status */
+export type IpLoadbalancingTaskStatusEnum = "blocked" | "cancelled" | "doing" | "done" | "error" | "todo";
+export declare const IpLoadbalancingTaskStatusEnum: any;
+/** Zone of your Load Balancer which are updated by current Task */
+export type IpLoadbalancingTaskTaskZonesList = Array<string>;
+export declare const IpLoadbalancingTaskTaskZonesList: S.Schema<IpLoadbalancingTaskTaskZonesList>;
+/** IP Load Balancing Operations */
+export interface IpLoadbalancingTaskTask {
+    /** Operation type */
+    action?: IpLoadbalancingTaskActionEnum;
+    /** Creation date of your operation */
+    creationDate?: string;
+    /** Done date of your operation */
+    doneDate?: string | null;
+    /** Id of the operation */
+    id?: number;
+    /** Operation progress percentage */
+    progress?: number;
+    /** Current status of your operation */
+    status?: IpLoadbalancingTaskStatusEnum;
+    /** Zone of your Load Balancer which are updated by current Task */
+    zones?: IpLoadbalancingTaskTaskZonesList;
+}
+export declare const IpLoadbalancingTaskTask: S.Schema<IpLoadbalancingTaskTask>;
+/** Possible values for load balancing balance algorithm */
+export type IpLoadbalancingBalanceHTTPEnum = "first" | "leastconn" | "roundrobin" | "source" | "uri";
+export declare const IpLoadbalancingBalanceHTTPEnum: any;
+/** List of possible probe result matches. "status" is only supported for HTTP probes */
+export type IpLoadbalancingProbeExpectMatchEnum = "contains" | "default" | "internal" | "matches" | "status";
+export declare const IpLoadbalancingProbeExpectMatchEnum: any;
+/** List of possible method for HTTP probes. Consider using HEAD to save bandwidth when possible. */
+export type IpLoadbalancingProbeMethodEnum = "GET" | "HEAD" | "OPTIONS" | "internal";
+export declare const IpLoadbalancingProbeMethodEnum: any;
+/** Possible values for farm probe */
+export type IpLoadbalancingProbeTypeEnum = "http" | "internal" | "mysql" | "oco" | "pgsql" | "smtp" | "tcp";
+export declare const IpLoadbalancingProbeTypeEnum: any;
+/** Probe used to determine if a backend is alive and can handle requests */
+export interface IpLoadbalancingBackendProbe {
+    /** Force probe to run over a SSL layer. Defaults to false */
+    forceSsl?: boolean | null;
+    /** Seconds between each probe check. Must be > 30sec. Defaults to 30 */
+    interval?: number | null;
+    /** Matcher to use to valide "expect". "default" uses HAProxy's default behavior for this type of check. "status" is only supported for HTTP probes */
+    match?: IpLoadbalancingProbeExpectMatchEnum | (string & {}) | null;
+    /** HTTP method to use with "http" probe. Consider using HEAD to save bandwidth when possible. Defaults to "GET" */
+    method?: IpLoadbalancingProbeMethodEnum | (string & {}) | null;
+    /** Invert the matching operator effect */
+    negate?: boolean | null;
+    /** Server response expected when UP. Empty for "default", comma delimited list of statuses for "status", string for "contains", regex for "matches" */
+    pattern?: string | null;
+    /** Port used to probe your backend. Equal to farm port if null. Ignored for oco probe type */
+    port?: number | null;
+    /** Probe type. "tcp" if null */
+    type?: IpLoadbalancingProbeTypeEnum | (string & {}) | null;
+    /** URL to use for HTTP probes of the form [www.example.com]/path/to/check. Protocol will be ignored. Defaults to "/" */
+    url?: string | null;
+}
+export declare const IpLoadbalancingBackendProbe: S.Schema<IpLoadbalancingBackendProbe>;
+/** Possible values for HTTP backend stickiness */
+export type IpLoadbalancingStickinessHTTPEnum = "cookie" | "sourceIp";
+export declare const IpLoadbalancingStickinessHTTPEnum: any;
+export interface CreateIpLoadbalancingHttpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Load balancing algorithm. 'roundrobin' if null */
+    balance?: IpLoadbalancingBalanceHTTPEnum | (string & {});
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string;
+    /** Port attached to your farm ([1..49151]). Inherited from frontend if null */
+    port?: number;
+    /** Probe used to determine if a backend is alive and can handle requests */
+    probe?: IpLoadbalancingBackendProbe;
+    /** Stickiness type. No stickiness if null */
+    stickiness?: IpLoadbalancingStickinessHTTPEnum | (string & {});
+    /** Internal Load Balancer identifier of the vRack private network to attach to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number;
+    /** Zone of your farm */
+    zone: string;
+}
+export declare const CreateIpLoadbalancingHttpFarmRequest: S.Schema<CreateIpLoadbalancingHttpFarmRequest>;
+/** HTTP Farm */
+export interface IpLoadbalancingBackendHttpBackendHttp {
+    /** Load balancing algorithm. 'roundrobin' if null */
+    balance?: IpLoadbalancingBalanceHTTPEnum | null;
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string | null;
+    /** Id of your farm */
+    farmId?: number;
+    /** Port attached to your farm. Inherited from frontend if null */
+    port?: number | null;
+    /** Probe used to determine if a backend is alive and can handle requests. Defaults to tcp on the same port as the farm */
+    probe?: IpLoadbalancingBackendProbe | null;
+    /** Stickiness type. No stickiness if null */
+    stickiness?: IpLoadbalancingStickinessHTTPEnum | null;
+    /** Internal Load Balancer identifier of the vRack private network attached to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number | null;
+    /** Zone of you farm */
+    zone?: string;
+}
+export declare const IpLoadbalancingBackendHttpBackendHttp: S.Schema<IpLoadbalancingBackendHttpBackendHttp>;
+/** Possible values for OnMarkedDown type */
+export type IpLoadbalancingOnMarkedDownEnum = "shutdown-sessions";
+export declare const IpLoadbalancingOnMarkedDownEnum: any;
+/** Possible values for proxy type */
+export type IpLoadbalancingProxyProtocolVersionEnum = "v1" | "v2" | "v2-ssl" | "v2-ssl-cn";
+export declare const IpLoadbalancingProxyProtocolVersionEnum: any;
+/** Possible values for server status */
+export type IpLoadbalancingBackendCustomerServerStatusEnum = "active" | "inactive";
+export declare const IpLoadbalancingBackendCustomerServerStatusEnum: any;
+export interface CreateIpLoadbalancingHttpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Address of your server */
+    address: string;
+    /** Set server as backup. Default: 'false' */
+    backup?: boolean;
+    /** Certificate chain. Allow server certificate verification (Avoid man-in-the-middle attacks) */
+    chain?: string;
+    /** Set the cookie value used when 'cookie' stickiness is set in the farm. Auto generate the cookie if none provided and required. */
+    cookie?: string;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string;
+    /** Enable action when backend marked down. (No action if null) */
+    onMarkedDown?: IpLoadbalancingOnMarkedDownEnum | (string & {});
+    /** Port attached to your server ([1..49151]). Inherited from farm if null */
+    port?: number;
+    /** Enable/disable probe. Default: 'false' */
+    probe?: boolean;
+    /** Disabled if null. Send PROXY protocol header. Requires a compatible server. */
+    proxyProtocolVersion?: IpLoadbalancingProxyProtocolVersionEnum | (string & {});
+    /** SSL ciphering. Probes will also be sent ciphered. Default: 'false' */
+    ssl?: boolean;
+    /** Enable or disable your server */
+    status: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+    /** Set weight on that server [1..256]. 0 if not used in load balancing. 1 if left null. Servers with higher weight get more requests. */
+    weight?: number;
+}
+export declare const CreateIpLoadbalancingHttpFarmServerRequest: S.Schema<CreateIpLoadbalancingHttpFarmServerRequest>;
+/** Available servers states */
+export interface IpLoadbalancingServerState {
+    /** Layer5-7 code, if available */
+    checkCode?: string | null;
+    /** Status of last health check */
+    checkStatus?: string | null;
+    /** Time of last health check */
+    checkTime?: string | null;
+    /** Id of your instance */
+    instanceId?: number;
+    /** Last health check contents or textual error */
+    lastCheckContent?: string | null;
+    /** Status */
+    status?: string | null;
+}
+export declare const IpLoadbalancingServerState: S.Schema<IpLoadbalancingServerState>;
+/** Server state */
+export type IpLoadbalancingBackendHttpCustomerServerBackendHTTPServerServerStateList = Array<IpLoadbalancingServerState>;
+export declare const IpLoadbalancingBackendHttpCustomerServerBackendHTTPServerServerStateList: S.Schema<IpLoadbalancingBackendHttpCustomerServerBackendHTTPServerServerStateList>;
+/** HTTP Farm's Server */
+export interface IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer {
+    /** Address of your server */
+    address?: string;
+    /** farm id */
+    backendId?: number;
+    /** Backup state. Default: 'false' */
+    backup?: boolean;
+    /** Certificate chain. Allow server certificate verification (Avoid man-in-the-middle attacks) */
+    chain?: string | null;
+    /** Server cookie value configured for cookie stickiness */
+    cookie?: string | null;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string | null;
+    /** Set action when backend marked down. (No action if null) */
+    onMarkedDown?: IpLoadbalancingOnMarkedDownEnum | null;
+    /** Port attached to your server. Inherited from farm if null */
+    port?: number | null;
+    /** Probe state. Default: 'false' */
+    probe?: boolean;
+    /** Disabled if null. Send PROXY protocol header. Requires a compatible server. */
+    proxyProtocolVersion?: IpLoadbalancingProxyProtocolVersionEnum | null;
+    /** Id of your server */
+    serverId?: number;
+    /** Server state */
+    serverState?: IpLoadbalancingBackendHttpCustomerServerBackendHTTPServerServerStateList;
+    /** SSL ciphering. Probes will also be sent ciphered. Default: 'false' */
+    ssl?: boolean;
+    /** Status attached to your server */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum;
+    /** Weight value. Defaults to 1. 0 if not used in load balancing. Servers with higher weight get more requests. */
+    weight?: number | null;
+}
+export declare const IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer: S.Schema<IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer>;
+export interface CreateIpLoadbalancingHttpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    address: string;
+    slotId: number;
+}
+export declare const CreateIpLoadbalancingHttpFarmServerTransparentRequest: S.Schema<CreateIpLoadbalancingHttpFarmServerTransparentRequest>;
+/** Server's vrack transparent ip */
+export interface IpLoadbalancingVrackTransparentIpVrackTransparentIp {
+    address?: string;
+    farmId?: number;
+    id?: number;
+    serverId?: number;
+    slotId?: number;
+}
+export declare const IpLoadbalancingVrackTransparentIpVrackTransparentIp: S.Schema<IpLoadbalancingVrackTransparentIpVrackTransparentIp>;
+/** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type CreateIpLoadbalancingHttpFrontendRequestAllowedSourceList = Array<string>;
+export declare const CreateIpLoadbalancingHttpFrontendRequestAllowedSourceList: S.Schema<CreateIpLoadbalancingHttpFrontendRequestAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type CreateIpLoadbalancingHttpFrontendRequestDedicatedIpfoList = Array<string>;
+export declare const CreateIpLoadbalancingHttpFrontendRequestDedicatedIpfoList: S.Schema<CreateIpLoadbalancingHttpFrontendRequestDedicatedIpfoList>;
+/** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type CreateIpLoadbalancingHttpFrontendRequestDeniedSourceList = Array<string>;
+export declare const CreateIpLoadbalancingHttpFrontendRequestDeniedSourceList: S.Schema<CreateIpLoadbalancingHttpFrontendRequestDeniedSourceList>;
+/** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+export type CreateIpLoadbalancingHttpFrontendRequestHttpHeaderList = Array<string>;
+export declare const CreateIpLoadbalancingHttpFrontendRequestHttpHeaderList: S.Schema<CreateIpLoadbalancingHttpFrontendRequestHttpHeaderList>;
+export interface CreateIpLoadbalancingHttpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: CreateIpLoadbalancingHttpFrontendRequestAllowedSourceList;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: CreateIpLoadbalancingHttpFrontendRequestDedicatedIpfoList;
+    /** Default HTTP Farm of your frontend */
+    defaultFarmId?: number;
+    /** Default ssl served to your customer */
+    defaultSslId?: number;
+    /** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: CreateIpLoadbalancingHttpFrontendRequestDeniedSourceList;
+    /** Disable your frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string;
+    /** HTTP Strict Transport Security. Default: 'false' */
+    hsts?: boolean;
+    /** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+    httpHeader?: CreateIpLoadbalancingHttpFrontendRequestHttpHeaderList;
+    /** Port(s) attached to your frontend. Supports single port (numerical value), range (2 dash-delimited increasing ports) and comma-separated list of 'single port' and/or 'range'. Each port must be in the [1;49151] range. */
+    port: string;
+    /** HTTP redirection (Ex : http://www.ovh.com) */
+    redirectLocation?: string;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Zone of your frontend. Use "all" for all owned zone. */
+    zone: string;
+}
+export declare const CreateIpLoadbalancingHttpFrontendRequest: S.Schema<CreateIpLoadbalancingHttpFrontendRequest>;
+/** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type IpLoadbalancingFrontendHttpFrontendHttpAllowedSourceList = Array<string>;
+export declare const IpLoadbalancingFrontendHttpFrontendHttpAllowedSourceList: S.Schema<IpLoadbalancingFrontendHttpFrontendHttpAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type IpLoadbalancingFrontendHttpFrontendHttpDedicatedIpfoList = Array<string>;
+export declare const IpLoadbalancingFrontendHttpFrontendHttpDedicatedIpfoList: S.Schema<IpLoadbalancingFrontendHttpFrontendHttpDedicatedIpfoList>;
+/** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type IpLoadbalancingFrontendHttpFrontendHttpDeniedSourceList = Array<string>;
+export declare const IpLoadbalancingFrontendHttpFrontendHttpDeniedSourceList: S.Schema<IpLoadbalancingFrontendHttpFrontendHttpDeniedSourceList>;
+/** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+export type IpLoadbalancingFrontendHttpFrontendHttpHttpHeaderList = Array<string>;
+export declare const IpLoadbalancingFrontendHttpFrontendHttpHttpHeaderList: S.Schema<IpLoadbalancingFrontendHttpFrontendHttpHttpHeaderList>;
+/** Frontend HTTP */
+export interface IpLoadbalancingFrontendHttpFrontendHttp {
+    /** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: IpLoadbalancingFrontendHttpFrontendHttpAllowedSourceList | null;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: IpLoadbalancingFrontendHttpFrontendHttpDedicatedIpfoList | null;
+    /** Default HTTP Farm of your frontend */
+    defaultFarmId?: number | null;
+    /** Default ssl served to your customer */
+    defaultSslId?: number | null;
+    /** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: IpLoadbalancingFrontendHttpFrontendHttpDeniedSourceList | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string | null;
+    /** Id of your frontend */
+    frontendId?: number;
+    /** HTTP Strict Transport Security. Default: 'false' */
+    hsts?: boolean;
+    /** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+    httpHeader?: IpLoadbalancingFrontendHttpFrontendHttpHttpHeaderList | null;
+    /** Listening port(s) on the server */
+    port?: string;
+    /** HTTP redirection (Ex : http://www.ovh.com) */
+    redirectLocation?: string | null;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Internal Load Balancer identifier of the vRack private network attached to your frontend. */
+    vrackNetworkId?: number | null;
+    /** Virtual Router Identifier. 1-255 */
+    vrackVrouterId?: number | null;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const IpLoadbalancingFrontendHttpFrontendHttp: S.Schema<IpLoadbalancingFrontendHttpFrontendHttp>;
+/** Address of the frontend in the vrack. Null to disable */
+export type CreateIpLoadbalancingHttpFrontendPrivateRequestDedicatedIpfoList = Array<string>;
+export declare const CreateIpLoadbalancingHttpFrontendPrivateRequestDedicatedIpfoList: S.Schema<CreateIpLoadbalancingHttpFrontendPrivateRequestDedicatedIpfoList>;
+export interface CreateIpLoadbalancingHttpFrontendPrivateRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+    /** Address of the frontend in the vrack. Null to disable */
+    dedicatedIpfo?: CreateIpLoadbalancingHttpFrontendPrivateRequestDedicatedIpfoList;
+    /** Internal Load Balancer identifier of the vRack private network to attach to your frontend. Null to disable */
+    vrackNetworkId?: number;
+    /** Virtual Router Identifier. 1-255 */
+    vrackVrouterId?: number;
+}
+export declare const CreateIpLoadbalancingHttpFrontendPrivateRequest: S.Schema<CreateIpLoadbalancingHttpFrontendPrivateRequest>;
+/** Restrict iplb access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type IpLoadbalancingFrontendFrontendAllowedSourceList = Array<string>;
+export declare const IpLoadbalancingFrontendFrontendAllowedSourceList: S.Schema<IpLoadbalancingFrontendFrontendAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type IpLoadbalancingFrontendFrontendDedicatedIpfoList = Array<string>;
+export declare const IpLoadbalancingFrontendFrontendDedicatedIpfoList: S.Schema<IpLoadbalancingFrontendFrontendDedicatedIpfoList>;
+/** Deny iplb access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type IpLoadbalancingFrontendFrontendDeniedSourceList = Array<string>;
+export declare const IpLoadbalancingFrontendFrontendDeniedSourceList: S.Schema<IpLoadbalancingFrontendFrontendDeniedSourceList>;
+/** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+export type IpLoadbalancingFrontendFrontendHttpHeaderList = Array<string>;
+export declare const IpLoadbalancingFrontendFrontendHttpHeaderList: S.Schema<IpLoadbalancingFrontendFrontendHttpHeaderList>;
+/** Possible values for proxy type */
+export type IpLoadbalancingProxyTypeEnum = "http" | "tcp";
+export declare const IpLoadbalancingProxyTypeEnum: any;
+/** Frontend */
+export interface IpLoadbalancingFrontendFrontend {
+    /** Restrict iplb access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: IpLoadbalancingFrontendFrontendAllowedSourceList | null;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: IpLoadbalancingFrontendFrontendDedicatedIpfoList | null;
+    /** Default Backend of your frontend */
+    defaultBackendId?: number | null;
+    /** Default ssl served to your customer */
+    defaultSslId?: number | null;
+    /** Deny iplb access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: IpLoadbalancingFrontendFrontendDeniedSourceList | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** HTTP Strict Transport Security. Default: 'false' */
+    hsts?: boolean;
+    /** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+    httpHeader?: IpLoadbalancingFrontendFrontendHttpHeaderList | null;
+    /** Id of your frontend */
+    id?: number;
+    /** Port(s) attached to your frontend */
+    port?: string;
+    /** HTTP redirection (Ex : http://www.ovh.com) */
+    redirectLocation?: string | null;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Type of your frontend */
+    type?: IpLoadbalancingProxyTypeEnum;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const IpLoadbalancingFrontendFrontend: S.Schema<IpLoadbalancingFrontendFrontend>;
+/** Action triggered when all rules from route match */
+export interface IpLoadbalancingRouteHttpAction {
+    /** HTTP status code for "redirect" and "reject" actions */
+    status?: number | null;
+    /** Farm ID for "farm" action type or URL template for "redirect" action. You may use ${uri}, ${protocol}, ${host}, ${port} and ${path} variables in redirect target */
+    target?: string | null;
+    /** Action to trigger if all the rules of this route matches */
+    type?: string;
+}
+export declare const IpLoadbalancingRouteHttpAction: S.Schema<IpLoadbalancingRouteHttpAction>;
+export interface CreateIpLoadbalancingHttpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Action triggered when all rules match */
+    action: IpLoadbalancingRouteHttpAction;
+    /** Human readable name for your route, this field is for you */
+    displayName?: string;
+    /** Route traffic for this frontend */
+    frontendId?: number;
+    /** Route priority ([0..255]). 0 if null. Highest priority routes are evaluated last. Only the first matching route will trigger an action */
+    weight?: number;
+}
+export declare const CreateIpLoadbalancingHttpRouteRequest: S.Schema<CreateIpLoadbalancingHttpRouteRequest>;
+/** List of possible route rule matches */
+export type IpLoadbalancingRouteRuleMatchesEnum = "contains" | "endswith" | "exists" | "in" | "internal" | "is" | "matches" | "startswith";
+export declare const IpLoadbalancingRouteRuleMatchesEnum: any;
+/** Match rule to combine to build routes */
+export interface IpLoadbalancingRouteRule {
+    /** Name of the field to match like "protocol" or "host". See "/ipLoadbalancing/{serviceName}/route/availableRules" for a list of available rules */
+    field?: string;
+    /** Matching operator. Not all operators are available for all fields. See "/availableRules" */
+    match?: IpLoadbalancingRouteRuleMatchesEnum;
+    /** Invert the matching operator effect */
+    negate?: boolean;
+    /** Value to match against this match. Interpretation if this field depends on the match and field */
+    pattern?: string | null;
+    /** Id of your rule */
+    ruleId?: number;
+    /** Name of sub-field, if applicable. This may be a Cookie or Header name for instance */
+    subField?: string | null;
+}
+export declare const IpLoadbalancingRouteRule: S.Schema<IpLoadbalancingRouteRule>;
+/** List of rules to match to trigger action */
+export type IpLoadbalancingRouteHttpRouteHttpRulesList = Array<IpLoadbalancingRouteRule>;
+export declare const IpLoadbalancingRouteHttpRouteHttpRulesList: S.Schema<IpLoadbalancingRouteHttpRouteHttpRulesList>;
+/** Route configuration status */
+export type IpLoadbalancingRouteStatusEnum = "creating" | "deleting" | "internal" | "ok" | "updating";
+export declare const IpLoadbalancingRouteStatusEnum: any;
+/** HTTP Route */
+export interface IpLoadbalancingRouteHttpRouteHttp {
+    /** Action triggered when all rules match */
+    action?: IpLoadbalancingRouteHttpAction;
+    /** Human readable name for your route, this field is for you */
+    displayName?: string | null;
+    /** Route traffic for this frontend */
+    frontendId?: number | null;
+    /** Id of your route */
+    routeId?: number;
+    /** List of rules to match to trigger action */
+    rules?: IpLoadbalancingRouteHttpRouteHttpRulesList;
+    /** Route status. Routes in "ok" state are ready to operate */
+    status?: IpLoadbalancingRouteStatusEnum;
+    /** Route priority ([0..255]). 0 if null. Highest priority routes are evaluated last. Only the first matching route will trigger an action */
+    weight?: number;
+}
+export declare const IpLoadbalancingRouteHttpRouteHttp: S.Schema<IpLoadbalancingRouteHttpRouteHttp>;
+export interface CreateIpLoadbalancingHttpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Human readable name for your rule */
+    displayName?: string;
+    /** Name of the field to match like "protocol" or "host". See "/ipLoadbalancing/{serviceName}/availableRouteRules" for a list of available rules */
+    field: string;
+    /** Matching operator. Not all operators are available for all fields. See "/ipLoadbalancing/{serviceName}/availableRouteRules" */
+    match: IpLoadbalancingRouteRuleMatchesEnum | (string & {});
+    /** Invert the matching operator effect */
+    negate?: boolean;
+    /** Value to match against this match. Interpretation if this field depends on the match and field */
+    pattern?: string;
+    /** Name of sub-field, if applicable. This may be a Cookie or Header name for instance */
+    subField?: string;
+}
+export declare const CreateIpLoadbalancingHttpRouteRuleRequest: S.Schema<CreateIpLoadbalancingHttpRouteRuleRequest>;
+/** Rule of a route */
+export interface IpLoadbalancingRouteRuleRouteRule {
+    /** Human readable name for your rule */
+    displayName?: string | null;
+    /** Name of the field to match like "protocol" or "host". See "/ipLoadbalancing/{serviceName}/availableRouteRules" for a list of available rules */
+    field?: string;
+    /** Matching operator. Not all operators are available for all fields. See "/ipLoadbalancing/{serviceName}/availableRouteRules" */
+    match?: IpLoadbalancingRouteRuleMatchesEnum;
+    /** Invert the matching operator effect */
+    negate?: boolean;
+    /** Value to match against this match. Interpretation if this field depends on the match and field */
+    pattern?: string | null;
+    /** Id of your rule */
+    ruleId?: number;
+    /** Name of sub-field, if applicable. This may be a Cookie or Header name for instance */
+    subField?: string | null;
+}
+export declare const IpLoadbalancingRouteRuleRouteRule: S.Schema<IpLoadbalancingRouteRuleRouteRule>;
+export interface CreateIpLoadbalancingLogSubscriptionRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Log kind name of the subscription */
+    kind: string;
+    /** Id of the destination log stream */
+    streamId: string;
+}
+export declare const CreateIpLoadbalancingLogSubscriptionRequest: S.Schema<CreateIpLoadbalancingLogSubscriptionRequest>;
+/** Logs subscription response for your Load Balancer */
+export interface IpLoadbalancingLogSubscriptionResponse {
+    /** The operation id of the subscription creation task */
+    operationId?: string;
+    /** The logs account */
+    serviceName?: string;
+}
+export declare const IpLoadbalancingLogSubscriptionResponse: S.Schema<IpLoadbalancingLogSubscriptionResponse>;
+export interface CreateIpLoadbalancingLogUrlRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Log kinds for your dedicated cloud */
+    kind: string;
+}
+export declare const CreateIpLoadbalancingLogUrlRequest: S.Schema<CreateIpLoadbalancingLogUrlRequest>;
+/** URL with real time logs */
+export interface IpLoadbalancingLogUrl {
+    /** Expiration date */
+    expirationDate?: string;
+    /** URL */
+    url?: string;
+}
+export declare const IpLoadbalancingLogUrl: S.Schema<IpLoadbalancingLogUrl>;
+export interface CreateIpLoadbalancingSslRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Certificate */
+    certificate: string;
+    /** Certificate chain */
+    chain?: string;
+    /** Human readable name for your ssl certificate, this field is for you */
+    displayName?: string;
+    /** Certificate key */
+    key: string;
+}
+export declare const CreateIpLoadbalancingSslRequest: S.Schema<CreateIpLoadbalancingSslRequest>;
+/** Subject Alternative Name of your SSL certificate */
+export type IpLoadbalancingSslSslSanList = Array<string>;
+export declare const IpLoadbalancingSslSslSanList: S.Schema<IpLoadbalancingSslSslSanList>;
+/** Possible values for ssl type */
+export type IpLoadbalancingSslTypeEnum = "built" | "built_not_routed" | "custom";
+export declare const IpLoadbalancingSslTypeEnum: any;
+/** Ssl */
+export interface IpLoadbalancingSslSsl {
+    /** Human readable name for your ssl certificate, this field is for you */
+    displayName?: string | null;
+    /** Expire date of your SSL certificate */
+    expireDate?: string;
+    /** Fingerprint of your SSL certificate */
+    fingerprint?: string;
+    /** Id of your SSL certificate */
+    id?: number;
+    /** Subject Alternative Name of your SSL certificate */
+    san?: IpLoadbalancingSslSslSanList;
+    /** Serial of your SSL certificate (Deprecated, use fingerprint instead !) */
+    serial?: string;
+    /** Subject of your SSL certificate */
+    subject?: string;
+    /** Type of your SSL certificate. 'built' for SSL certificates managed by the IP Load Balancing. 'custom' for user manager certificates. */
+    type?: IpLoadbalancingSslTypeEnum | null;
+}
+export declare const IpLoadbalancingSslSsl: S.Schema<IpLoadbalancingSslSsl>;
+/** Possible values for load balancing balance algorithm */
+export type IpLoadbalancingBalanceTCPEnum = "first" | "leastconn" | "roundrobin" | "source";
+export declare const IpLoadbalancingBalanceTCPEnum: any;
+/** Possible values for TCP backend stickiness */
+export type IpLoadbalancingStickinessTCPEnum = "sourceIp";
+export declare const IpLoadbalancingStickinessTCPEnum: any;
+export interface CreateIpLoadbalancingTcpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Load balancing algorithm. 'roundrobin' if null */
+    balance?: IpLoadbalancingBalanceTCPEnum | (string & {});
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string;
+    /** Port attached to your farm ([1..49151]). Inherited from frontend if null */
+    port?: number;
+    /** Probe used to determine if a backend is alive and can handle requests */
+    probe?: IpLoadbalancingBackendProbe;
+    /** Stickiness type. No stickiness if null */
+    stickiness?: IpLoadbalancingStickinessTCPEnum | (string & {});
+    /** Internal Load Balancer identifier of the vRack private network to attach to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number;
+    /** Zone of your farm */
+    zone: string;
+}
+export declare const CreateIpLoadbalancingTcpFarmRequest: S.Schema<CreateIpLoadbalancingTcpFarmRequest>;
+/** TCP Farm */
+export interface IpLoadbalancingBackendTcpBackendTcp {
+    /** Load balancing algorithm. 'roundrobin' if null */
+    balance?: IpLoadbalancingBalanceTCPEnum | null;
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string | null;
+    /** Id of your farm */
+    farmId?: number;
+    /** Port attached to your farm. Inherited from frontend if null */
+    port?: number | null;
+    /** Probe used to determine if a backend is alive and can handle requests. Defaults to tcp on the same port as the farm */
+    probe?: IpLoadbalancingBackendProbe | null;
+    /** Stickiness type. No stickiness if null */
+    stickiness?: IpLoadbalancingStickinessTCPEnum | null;
+    /** Internal Load Balancer identifier of the vRack private network attached to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number | null;
+    /** Zone of you farm */
+    zone?: string;
+}
+export declare const IpLoadbalancingBackendTcpBackendTcp: S.Schema<IpLoadbalancingBackendTcpBackendTcp>;
+export interface CreateIpLoadbalancingTcpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Address of your server */
+    address: string;
+    /** Set server as backup. Default: 'false' */
+    backup?: boolean;
+    /** Certificate chain. Allow server certificate verification (Avoid man-in-the-middle attacks) */
+    chain?: string;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string;
+    /** Enable action when backend marked down. (No action if null) */
+    onMarkedDown?: IpLoadbalancingOnMarkedDownEnum | (string & {});
+    /** Port attached to your server ([1..49151]). Inherited from farm if null */
+    port?: number;
+    /** Enable/disable probe. Default: 'false' */
+    probe?: boolean;
+    /** Disabled if null. Send PROXY protocol header. Requires a compatible server. */
+    proxyProtocolVersion?: IpLoadbalancingProxyProtocolVersionEnum | (string & {});
+    /** SSL ciphering. Probes will also be sent ciphered. Default: 'false' */
+    ssl?: boolean;
+    /** Enable or disable your server */
+    status: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+    /** Set weight on that server [1..256]. 0 if not used in load balancing. 1 if left null. Servers with higher weight get more requests. */
+    weight?: number;
+}
+export declare const CreateIpLoadbalancingTcpFarmServerRequest: S.Schema<CreateIpLoadbalancingTcpFarmServerRequest>;
+/** Server state */
+export type IpLoadbalancingBackendTcpCustomerServerBackendTCPServerServerStateList = Array<IpLoadbalancingServerState>;
+export declare const IpLoadbalancingBackendTcpCustomerServerBackendTCPServerServerStateList: S.Schema<IpLoadbalancingBackendTcpCustomerServerBackendTCPServerServerStateList>;
+/** TCP Farm's Server */
+export interface IpLoadbalancingBackendTcpCustomerServerBackendTCPServer {
+    /** Address of your server */
+    address?: string;
+    /** Farm id */
+    backendId?: number;
+    /** Backup state. Default: 'false' */
+    backup?: boolean;
+    /** Certificate chain. Allow server certificate verification (Avoid man-in-the-middle attacks) */
+    chain?: string | null;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string | null;
+    /** Set action when backend marked down. (No action if null) */
+    onMarkedDown?: IpLoadbalancingOnMarkedDownEnum | null;
+    /** Port attached to your server. Inherited from farm if null */
+    port?: number | null;
+    /** Probe state. Default: 'false' */
+    probe?: boolean;
+    /** Disabled if null. Send PROXY protocol header. Requires a compatible server. */
+    proxyProtocolVersion?: IpLoadbalancingProxyProtocolVersionEnum | null;
+    /** Id of your server */
+    serverId?: number;
+    /** Server state */
+    serverState?: IpLoadbalancingBackendTcpCustomerServerBackendTCPServerServerStateList;
+    /** SSL ciphering. Probes will also be sent ciphered */
+    ssl?: boolean;
+    /** Status attached to your server */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum;
+    /** Weight value. Defaults to 1. 0 if not used in load balancing. Servers with higher weight get more requests. */
+    weight?: number | null;
+}
+export declare const IpLoadbalancingBackendTcpCustomerServerBackendTCPServer: S.Schema<IpLoadbalancingBackendTcpCustomerServerBackendTCPServer>;
+export interface CreateIpLoadbalancingTcpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    address: string;
+    slotId: number;
+}
+export declare const CreateIpLoadbalancingTcpFarmServerTransparentRequest: S.Schema<CreateIpLoadbalancingTcpFarmServerTransparentRequest>;
+/** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type CreateIpLoadbalancingTcpFrontendRequestAllowedSourceList = Array<string>;
+export declare const CreateIpLoadbalancingTcpFrontendRequestAllowedSourceList: S.Schema<CreateIpLoadbalancingTcpFrontendRequestAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type CreateIpLoadbalancingTcpFrontendRequestDedicatedIpfoList = Array<string>;
+export declare const CreateIpLoadbalancingTcpFrontendRequestDedicatedIpfoList: S.Schema<CreateIpLoadbalancingTcpFrontendRequestDedicatedIpfoList>;
+/** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type CreateIpLoadbalancingTcpFrontendRequestDeniedSourceList = Array<string>;
+export declare const CreateIpLoadbalancingTcpFrontendRequestDeniedSourceList: S.Schema<CreateIpLoadbalancingTcpFrontendRequestDeniedSourceList>;
+export interface CreateIpLoadbalancingTcpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: CreateIpLoadbalancingTcpFrontendRequestAllowedSourceList;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: CreateIpLoadbalancingTcpFrontendRequestDedicatedIpfoList;
+    /** Default TCP Farm of your frontend */
+    defaultFarmId?: number;
+    /** Default ssl served to your customer */
+    defaultSslId?: number;
+    /** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: CreateIpLoadbalancingTcpFrontendRequestDeniedSourceList;
+    /** Disable your frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string;
+    /** Port(s) attached to your frontend. Supports single port (numerical value), range (2 dash-delimited increasing ports) and comma-separated list of 'single port' and/or 'range'. Each port must be in the [1;49151] range. */
+    port: string;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Zone of your frontend. Use "all" for all owned zone. */
+    zone: string;
+}
+export declare const CreateIpLoadbalancingTcpFrontendRequest: S.Schema<CreateIpLoadbalancingTcpFrontendRequest>;
+/** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type IpLoadbalancingFrontendTcpFrontendTcpAllowedSourceList = Array<string>;
+export declare const IpLoadbalancingFrontendTcpFrontendTcpAllowedSourceList: S.Schema<IpLoadbalancingFrontendTcpFrontendTcpAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type IpLoadbalancingFrontendTcpFrontendTcpDedicatedIpfoList = Array<string>;
+export declare const IpLoadbalancingFrontendTcpFrontendTcpDedicatedIpfoList: S.Schema<IpLoadbalancingFrontendTcpFrontendTcpDedicatedIpfoList>;
+/** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type IpLoadbalancingFrontendTcpFrontendTcpDeniedSourceList = Array<string>;
+export declare const IpLoadbalancingFrontendTcpFrontendTcpDeniedSourceList: S.Schema<IpLoadbalancingFrontendTcpFrontendTcpDeniedSourceList>;
+/** Frontend TCP */
+export interface IpLoadbalancingFrontendTcpFrontendTcp {
+    /** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: IpLoadbalancingFrontendTcpFrontendTcpAllowedSourceList | null;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: IpLoadbalancingFrontendTcpFrontendTcpDedicatedIpfoList | null;
+    /** Default TCP Farm of your frontend */
+    defaultFarmId?: number | null;
+    /** Default ssl served to your customer */
+    defaultSslId?: number | null;
+    /** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: IpLoadbalancingFrontendTcpFrontendTcpDeniedSourceList | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string | null;
+    /** Id of your frontend */
+    frontendId?: number;
+    /** Listening port(s) on the server */
+    port?: string;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Internal Load Balancer identifier of the vRack private network attached to your frontend. */
+    vrackNetworkId?: number | null;
+    /** Virtual Router Identifier. 1-255 */
+    vrackVrouterId?: number | null;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const IpLoadbalancingFrontendTcpFrontendTcp: S.Schema<IpLoadbalancingFrontendTcpFrontendTcp>;
+/** Address of the frontend in the vrack. Null to disable */
+export type CreateIpLoadbalancingTcpFrontendPrivateRequestDedicatedIpfoList = Array<string>;
+export declare const CreateIpLoadbalancingTcpFrontendPrivateRequestDedicatedIpfoList: S.Schema<CreateIpLoadbalancingTcpFrontendPrivateRequestDedicatedIpfoList>;
+export interface CreateIpLoadbalancingTcpFrontendPrivateRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+    /** Address of the frontend in the vrack. Null to disable */
+    dedicatedIpfo?: CreateIpLoadbalancingTcpFrontendPrivateRequestDedicatedIpfoList;
+    /** Internal Load Balancer identifier of the vRack private network to attach to your frontend. Null to disable */
+    vrackNetworkId?: number;
+    /** Virtual Router Identifier. 1-255 */
+    vrackVrouterId?: number;
+}
+export declare const CreateIpLoadbalancingTcpFrontendPrivateRequest: S.Schema<CreateIpLoadbalancingTcpFrontendPrivateRequest>;
+/** Action triggered when all rules from route match */
+export interface IpLoadbalancingRouteTcpAction {
+    /** Farm ID for "farm" action type, empty for others */
+    target?: string | null;
+    /** Action to trigger if all the rules of this route matches */
+    type?: string;
+}
+export declare const IpLoadbalancingRouteTcpAction: S.Schema<IpLoadbalancingRouteTcpAction>;
+export interface CreateIpLoadbalancingTcpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Action triggered when all rules match */
+    action: IpLoadbalancingRouteTcpAction;
+    /** Human readable name for your route, this field is for you */
+    displayName?: string;
+    /** Route traffic for this frontend */
+    frontendId?: number;
+    /** Route priority ([0..255]). 0 if null. Highest priority routes are evaluated last. Only the first matching route will trigger an action */
+    weight?: number;
+}
+export declare const CreateIpLoadbalancingTcpRouteRequest: S.Schema<CreateIpLoadbalancingTcpRouteRequest>;
+/** List of rules to match to trigger action */
+export type IpLoadbalancingRouteTcpRouteTcpRulesList = Array<IpLoadbalancingRouteRule>;
+export declare const IpLoadbalancingRouteTcpRouteTcpRulesList: S.Schema<IpLoadbalancingRouteTcpRouteTcpRulesList>;
+/** TCP Route */
+export interface IpLoadbalancingRouteTcpRouteTcp {
+    /** Action triggered when all rules match */
+    action?: IpLoadbalancingRouteTcpAction;
+    /** Human readable name for your route, this field is for you */
+    displayName?: string | null;
+    /** Route traffic for this frontend */
+    frontendId?: number | null;
+    /** Id of your route */
+    routeId?: number;
+    /** List of rules to match to trigger action */
+    rules?: IpLoadbalancingRouteTcpRouteTcpRulesList;
+    /** Route status. Routes in "ok" state are ready to operate */
+    status?: IpLoadbalancingRouteStatusEnum;
+    /** Route priority ([0..255]). 0 if null. Highest priority routes are evaluated last. Only the first matching route will trigger an action */
+    weight?: number;
+}
+export declare const IpLoadbalancingRouteTcpRouteTcp: S.Schema<IpLoadbalancingRouteTcpRouteTcp>;
+export interface CreateIpLoadbalancingTcpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Human readable name for your rule */
+    displayName?: string;
+    /** Name of the field to match like "protocol" or "host". See "/ipLoadbalancing/{serviceName}/availableRouteRules" for a list of available rules */
+    field: string;
+    /** Matching operator. Not all operators are available for all fields. See "/ipLoadbalancing/{serviceName}/availableRouteRules" */
+    match: IpLoadbalancingRouteRuleMatchesEnum | (string & {});
+    /** Invert the matching operator effect */
+    negate?: boolean;
+    /** Value to match against this match. Interpretation if this field depends on the match and field */
+    pattern?: string;
+    /** Name of sub-field, if applicable. This may be a Cookie or Header name for instance */
+    subField?: string;
+}
+export declare const CreateIpLoadbalancingTcpRouteRuleRequest: S.Schema<CreateIpLoadbalancingTcpRouteRuleRequest>;
+export interface CreateIpLoadbalancingUdpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string;
+    /** Port attached to your farm ([1..49151]). Inherited from frontend if null */
+    port: number;
+    /** Internal Load Balancer identifier of the vRack private network to attach to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number;
+    /** Zone of your farm */
+    zone: string;
+}
+export declare const CreateIpLoadbalancingUdpFarmRequest: S.Schema<CreateIpLoadbalancingUdpFarmRequest>;
+/** UDP Farm */
+export interface IpLoadbalancingBackendUdpBackendUdp {
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string | null;
+    /** Id of your farm */
+    farmId?: number;
+    /** Port attached to your farm. Inherited from frontend if null */
+    port?: number;
+    /** Internal Load Balancer identifier of the vRack private network attached to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number | null;
+    /** Zone of you farm */
+    zone?: string;
+}
+export declare const IpLoadbalancingBackendUdpBackendUdp: S.Schema<IpLoadbalancingBackendUdpBackendUdp>;
+export interface CreateIpLoadbalancingUdpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Address of your server */
+    address: string;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string;
+    /** Port attached to your server ([1..49151]). Inherited from farm if null */
+    port?: number;
+    /** Enable or disable your server */
+    status: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+}
+export declare const CreateIpLoadbalancingUdpFarmServerRequest: S.Schema<CreateIpLoadbalancingUdpFarmServerRequest>;
+/** UDP Farm's Server */
+export interface IpLoadbalancingBackendUdpCustomerServerBackendUDPServer {
+    /** Address of your server */
+    address?: string;
+    /** farm id */
+    backendId?: number;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string | null;
+    /** Port attached to your server. Inherited from farm if null */
+    port?: number | null;
+    /** Id of your server */
+    serverId?: number;
+    /** Status attached to your server */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum;
+}
+export declare const IpLoadbalancingBackendUdpCustomerServerBackendUDPServer: S.Schema<IpLoadbalancingBackendUdpCustomerServerBackendUDPServer>;
+/** Only attach frontend on these ip. No restriction if null */
+export type CreateIpLoadbalancingUdpFrontendRequestDedicatedIpfoList = Array<string>;
+export declare const CreateIpLoadbalancingUdpFrontendRequestDedicatedIpfoList: S.Schema<CreateIpLoadbalancingUdpFrontendRequestDedicatedIpfoList>;
+export interface CreateIpLoadbalancingUdpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: CreateIpLoadbalancingUdpFrontendRequestDedicatedIpfoList;
+    /** Default UDP Farm of your frontend */
+    defaultFarmId?: number;
+    /** Disable your frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string;
+    /** Port(s) attached to your frontend. Supports single port (numerical value), range (2 dash-delimited increasing ports) and comma-separated list of 'single port' and/or 'range'. Each port must be in the [1;49151] range. */
+    port: string;
+    /** Zone of your frontend. Use "all" for all owned zone. */
+    zone: string;
+}
+export declare const CreateIpLoadbalancingUdpFrontendRequest: S.Schema<CreateIpLoadbalancingUdpFrontendRequest>;
+/** Only attach frontend on these ip. No restriction if null */
+export type IpLoadbalancingFrontendUdpFrontendUdpDedicatedIpfoList = Array<string>;
+export declare const IpLoadbalancingFrontendUdpFrontendUdpDedicatedIpfoList: S.Schema<IpLoadbalancingFrontendUdpFrontendUdpDedicatedIpfoList>;
+/** Frontend UDP */
+export interface IpLoadbalancingFrontendUdpFrontendUdp {
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: IpLoadbalancingFrontendUdpFrontendUdpDedicatedIpfoList | null;
+    /** Default UDP Farm of your frontend */
+    defaultFarmId?: number | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string | null;
+    /** Id of your frontend */
+    frontendId?: number;
+    /** Listening port(s) on the server */
+    port?: string;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const IpLoadbalancingFrontendUdpFrontendUdp: S.Schema<IpLoadbalancingFrontendUdpFrontendUdp>;
+/** Farm Id you want to attach to that vrack network */
+export type CreateIpLoadbalancingVrackNetworkRequestFarmIdList = Array<number>;
+export declare const CreateIpLoadbalancingVrackNetworkRequestFarmIdList: S.Schema<CreateIpLoadbalancingVrackNetworkRequestFarmIdList>;
+export interface CreateIpLoadbalancingVrackNetworkRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Human readable name for your vrack network */
+    displayName?: string;
+    /** Farm Id you want to attach to that vrack network */
+    farmId?: CreateIpLoadbalancingVrackNetworkRequestFarmIdList;
+    /** An IP block used as a pool of IPs by this Load Balancer to connect to the servers in this private network. The block must be in the private network and reserved for the Load Balancer */
+    natIp: string;
+    /** IP Block of the private network in the vRack */
+    subnet: string;
+    /** VLAN of the private network in the vRack. 0 if the private network is not in a VLAN */
+    vlan?: number;
+}
+export declare const CreateIpLoadbalancingVrackNetworkRequest: S.Schema<CreateIpLoadbalancingVrackNetworkRequest>;
+/** a list of { type => [ Farm ids ] } */
+export interface IpLoadbalancingDefinedFarm {
+    id?: number;
+    type?: string;
+}
+export declare const IpLoadbalancingDefinedFarm: S.Schema<IpLoadbalancingDefinedFarm>;
+/** Farm Id your vrack network is attached to and their type */
+export type IpLoadbalancingVrackNetworkVrackNetworkFarmIdList = Array<IpLoadbalancingDefinedFarm>;
+export declare const IpLoadbalancingVrackNetworkVrackNetworkFarmIdList: S.Schema<IpLoadbalancingVrackNetworkVrackNetworkFarmIdList>;
+/** Represents a private network in the vRack */
+export interface IpLoadbalancingVrackNetworkVrackNetwork {
+    /** Human readable name for your vrack network */
+    displayName?: string | null;
+    /** Farm Id your vrack network is attached to and their type */
+    farmId?: IpLoadbalancingVrackNetworkVrackNetworkFarmIdList;
+    /** An IP block used as a pool of IPs by this Load Balancer to connect to the servers in this private network. The block must be in the private network and reserved for the Load Balancer */
+    natIp?: string;
+    /** IP block of the private network in the vRack */
+    subnet?: string;
+    /** VLAN of the private network in the vRack. 0 if the private network is not in a VLAN */
+    vlan?: number;
+    /** Internal Load Balancer identifier of the vRack private network description */
+    vrackNetworkId?: number;
+}
+export declare const IpLoadbalancingVrackNetworkVrackNetwork: S.Schema<IpLoadbalancingVrackNetworkVrackNetwork>;
+export interface DeleteIpLoadbalancingHttpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+}
+export declare const DeleteIpLoadbalancingHttpFarmRequest: S.Schema<DeleteIpLoadbalancingHttpFarmRequest>;
+export interface DeleteIpLoadbalancingHttpFarmResponse {
+}
+export declare const DeleteIpLoadbalancingHttpFarmResponse: S.Schema<DeleteIpLoadbalancingHttpFarmResponse>;
+export interface DeleteIpLoadbalancingHttpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+}
+export declare const DeleteIpLoadbalancingHttpFarmServerRequest: S.Schema<DeleteIpLoadbalancingHttpFarmServerRequest>;
+export interface DeleteIpLoadbalancingHttpFarmServerResponse {
+}
+export declare const DeleteIpLoadbalancingHttpFarmServerResponse: S.Schema<DeleteIpLoadbalancingHttpFarmServerResponse>;
+export interface DeleteIpLoadbalancingHttpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    transparentId: number;
+}
+export declare const DeleteIpLoadbalancingHttpFarmServerTransparentRequest: S.Schema<DeleteIpLoadbalancingHttpFarmServerTransparentRequest>;
+export interface DeleteIpLoadbalancingHttpFarmServerTransparentResponse {
+}
+export declare const DeleteIpLoadbalancingHttpFarmServerTransparentResponse: S.Schema<DeleteIpLoadbalancingHttpFarmServerTransparentResponse>;
+export interface DeleteIpLoadbalancingHttpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+}
+export declare const DeleteIpLoadbalancingHttpFrontendRequest: S.Schema<DeleteIpLoadbalancingHttpFrontendRequest>;
+export interface DeleteIpLoadbalancingHttpFrontendResponse {
+}
+export declare const DeleteIpLoadbalancingHttpFrontendResponse: S.Schema<DeleteIpLoadbalancingHttpFrontendResponse>;
+export interface DeleteIpLoadbalancingHttpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+}
+export declare const DeleteIpLoadbalancingHttpRouteRequest: S.Schema<DeleteIpLoadbalancingHttpRouteRequest>;
+export interface DeleteIpLoadbalancingHttpRouteResponse {
+}
+export declare const DeleteIpLoadbalancingHttpRouteResponse: S.Schema<DeleteIpLoadbalancingHttpRouteResponse>;
+export interface DeleteIpLoadbalancingHttpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Id of your rule */
+    ruleId: number;
+}
+export declare const DeleteIpLoadbalancingHttpRouteRuleRequest: S.Schema<DeleteIpLoadbalancingHttpRouteRuleRequest>;
+export interface DeleteIpLoadbalancingHttpRouteRuleResponse {
+}
+export declare const DeleteIpLoadbalancingHttpRouteRuleResponse: S.Schema<DeleteIpLoadbalancingHttpRouteRuleResponse>;
+export interface DeleteIpLoadbalancingLogSubscriptionRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const DeleteIpLoadbalancingLogSubscriptionRequest: S.Schema<DeleteIpLoadbalancingLogSubscriptionRequest>;
+export interface DeleteIpLoadbalancingSslRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your SSL certificate */
+    id: number;
+}
+export declare const DeleteIpLoadbalancingSslRequest: S.Schema<DeleteIpLoadbalancingSslRequest>;
+export interface DeleteIpLoadbalancingSslResponse {
+}
+export declare const DeleteIpLoadbalancingSslResponse: S.Schema<DeleteIpLoadbalancingSslResponse>;
+export interface DeleteIpLoadbalancingTcpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+}
+export declare const DeleteIpLoadbalancingTcpFarmRequest: S.Schema<DeleteIpLoadbalancingTcpFarmRequest>;
+export interface DeleteIpLoadbalancingTcpFarmResponse {
+}
+export declare const DeleteIpLoadbalancingTcpFarmResponse: S.Schema<DeleteIpLoadbalancingTcpFarmResponse>;
+export interface DeleteIpLoadbalancingTcpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+}
+export declare const DeleteIpLoadbalancingTcpFarmServerRequest: S.Schema<DeleteIpLoadbalancingTcpFarmServerRequest>;
+export interface DeleteIpLoadbalancingTcpFarmServerResponse {
+}
+export declare const DeleteIpLoadbalancingTcpFarmServerResponse: S.Schema<DeleteIpLoadbalancingTcpFarmServerResponse>;
+export interface DeleteIpLoadbalancingTcpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    transparentId: number;
+}
+export declare const DeleteIpLoadbalancingTcpFarmServerTransparentRequest: S.Schema<DeleteIpLoadbalancingTcpFarmServerTransparentRequest>;
+export interface DeleteIpLoadbalancingTcpFarmServerTransparentResponse {
+}
+export declare const DeleteIpLoadbalancingTcpFarmServerTransparentResponse: S.Schema<DeleteIpLoadbalancingTcpFarmServerTransparentResponse>;
+export interface DeleteIpLoadbalancingTcpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+}
+export declare const DeleteIpLoadbalancingTcpFrontendRequest: S.Schema<DeleteIpLoadbalancingTcpFrontendRequest>;
+export interface DeleteIpLoadbalancingTcpFrontendResponse {
+}
+export declare const DeleteIpLoadbalancingTcpFrontendResponse: S.Schema<DeleteIpLoadbalancingTcpFrontendResponse>;
+export interface DeleteIpLoadbalancingTcpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+}
+export declare const DeleteIpLoadbalancingTcpRouteRequest: S.Schema<DeleteIpLoadbalancingTcpRouteRequest>;
+export interface DeleteIpLoadbalancingTcpRouteResponse {
+}
+export declare const DeleteIpLoadbalancingTcpRouteResponse: S.Schema<DeleteIpLoadbalancingTcpRouteResponse>;
+export interface DeleteIpLoadbalancingTcpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Id of your rule */
+    ruleId: number;
+}
+export declare const DeleteIpLoadbalancingTcpRouteRuleRequest: S.Schema<DeleteIpLoadbalancingTcpRouteRuleRequest>;
+export interface DeleteIpLoadbalancingTcpRouteRuleResponse {
+}
+export declare const DeleteIpLoadbalancingTcpRouteRuleResponse: S.Schema<DeleteIpLoadbalancingTcpRouteRuleResponse>;
+export interface DeleteIpLoadbalancingUdpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+}
+export declare const DeleteIpLoadbalancingUdpFarmRequest: S.Schema<DeleteIpLoadbalancingUdpFarmRequest>;
+export interface DeleteIpLoadbalancingUdpFarmResponse {
+}
+export declare const DeleteIpLoadbalancingUdpFarmResponse: S.Schema<DeleteIpLoadbalancingUdpFarmResponse>;
+export interface DeleteIpLoadbalancingUdpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+}
+export declare const DeleteIpLoadbalancingUdpFarmServerRequest: S.Schema<DeleteIpLoadbalancingUdpFarmServerRequest>;
+export interface DeleteIpLoadbalancingUdpFarmServerResponse {
+}
+export declare const DeleteIpLoadbalancingUdpFarmServerResponse: S.Schema<DeleteIpLoadbalancingUdpFarmServerResponse>;
+export interface DeleteIpLoadbalancingUdpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+}
+export declare const DeleteIpLoadbalancingUdpFrontendRequest: S.Schema<DeleteIpLoadbalancingUdpFrontendRequest>;
+export interface DeleteIpLoadbalancingUdpFrontendResponse {
+}
+export declare const DeleteIpLoadbalancingUdpFrontendResponse: S.Schema<DeleteIpLoadbalancingUdpFrontendResponse>;
+export interface DeleteIpLoadbalancingVrackNetworkRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Internal Load Balancer identifier of the vRack private network description */
+    vrackNetworkId: number;
+}
+export declare const DeleteIpLoadbalancingVrackNetworkRequest: S.Schema<DeleteIpLoadbalancingVrackNetworkRequest>;
+export interface DeleteIpLoadbalancingVrackNetworkResponse {
+}
+export declare const DeleteIpLoadbalancingVrackNetworkResponse: S.Schema<DeleteIpLoadbalancingVrackNetworkResponse>;
+export interface GetIpLoadbalancingRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const GetIpLoadbalancingRequest: S.Schema<GetIpLoadbalancingRequest>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamResourceMetadataTagsMap: S.Schema<IamResourceMetadataTagsMap>;
+/** IAM resource metadata embedded in services models */
+export interface IamResourceMetadata {
+    /** Resource display name */
+    displayName?: string | null;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamResourceMetadataTagsMap | null;
+    /** Unique resource name used in policies */
+    urn?: string;
+}
+export declare const IamResourceMetadata: S.Schema<IamResourceMetadata>;
+/** Available additional zone to order for a Load Balancer */
+export interface IpLoadbalancingOrderableZone {
+    /** The zone three letter code */
+    name?: string;
+    /** The billing planCode for this zone */
+    planCode?: string;
+}
+export declare const IpLoadbalancingOrderableZone: S.Schema<IpLoadbalancingOrderableZone>;
+/** Available additional zone for your Load Balancer */
+export type IpLoadbalancingIpWithIAMOrderableZoneList = Array<IpLoadbalancingOrderableZone>;
+export declare const IpLoadbalancingIpWithIAMOrderableZoneList: S.Schema<IpLoadbalancingIpWithIAMOrderableZoneList>;
+/** Possible values for ssl ciphers */
+export type IpLoadbalancingSslConfigurationEnum = "intermediate" | "modern";
+export declare const IpLoadbalancingSslConfigurationEnum: any;
+/** Possible values for load balancing IP state */
+export type IpLoadbalancingIpStateEnum = "blacklisted" | "deleted" | "free" | "ok" | "quarantined" | "suspended";
+export declare const IpLoadbalancingIpStateEnum: any;
+/** Location where your service is */
+export type IpLoadbalancingIpWithIAMZoneList = Array<string>;
+export declare const IpLoadbalancingIpWithIAMZoneList: S.Schema<IpLoadbalancingIpWithIAMZoneList>;
+/** Your IP load balancing */
+export interface IpLoadbalancingIpWithIAM {
+    /** Set the name displayed in ManagerV6 for your iplb (max 50 chars) */
+    displayName?: string | null;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Your IP load balancing */
+    ipLoadbalancing?: string;
+    /** The IPV4 associated to your IP load balancing */
+    ipv4?: string | null;
+    /** The IPV6 associated to your IP load balancing */
+    ipv6?: string | null;
+    /** The metrics token associated with your IP load balancing */
+    metricsToken?: string | null;
+    /** The offer of your IP load balancing */
+    offer?: string;
+    /** Available additional zone for your Load Balancer */
+    orderableZone?: IpLoadbalancingIpWithIAMOrderableZoneList;
+    /** The internal name of your IP load balancing */
+    serviceName?: string;
+    /** Modern oldest compatible clients : Firefox 27, Chrome 30, IE 11 on Windows 7, Edge, Opera 17, Safari 9, Android 5.0, and Java 8. Intermediate oldest compatible clients : Firefox 1, Chrome 1, IE 7, Opera 5, Safari 1, Windows XP IE8, Android 2.3, Java 7. Intermediate if null. */
+    sslConfiguration?: IpLoadbalancingSslConfigurationEnum | null;
+    /** Current state of your IP */
+    state?: IpLoadbalancingIpStateEnum;
+    /** Vrack eligibility */
+    vrackEligibility?: boolean;
+    /** Name of the vRack on which the current Load Balancer is attached to, as it is named on vRack product */
+    vrackName?: string | null;
+    /** Location where your service is */
+    zone?: IpLoadbalancingIpWithIAMZoneList;
+}
+export declare const IpLoadbalancingIpWithIAM: S.Schema<IpLoadbalancingIpWithIAM>;
+export interface GetIpLoadbalancingHttpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+}
+export declare const GetIpLoadbalancingHttpFarmRequest: S.Schema<GetIpLoadbalancingHttpFarmRequest>;
+export interface GetIpLoadbalancingHttpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+}
+export declare const GetIpLoadbalancingHttpFarmServerRequest: S.Schema<GetIpLoadbalancingHttpFarmServerRequest>;
+export interface GetIpLoadbalancingHttpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    transparentId: number;
+}
+export declare const GetIpLoadbalancingHttpFarmServerTransparentRequest: S.Schema<GetIpLoadbalancingHttpFarmServerTransparentRequest>;
+export interface GetIpLoadbalancingHttpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+}
+export declare const GetIpLoadbalancingHttpFrontendRequest: S.Schema<GetIpLoadbalancingHttpFrontendRequest>;
+export interface GetIpLoadbalancingHttpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+}
+export declare const GetIpLoadbalancingHttpRouteRequest: S.Schema<GetIpLoadbalancingHttpRouteRequest>;
+export interface GetIpLoadbalancingHttpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Id of your rule */
+    ruleId: number;
+}
+export declare const GetIpLoadbalancingHttpRouteRuleRequest: S.Schema<GetIpLoadbalancingHttpRouteRuleRequest>;
+export interface GetIpLoadbalancingLogKindRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Log kind name */
+    name: string;
+}
+export declare const GetIpLoadbalancingLogKindRequest: S.Schema<GetIpLoadbalancingLogKindRequest>;
+/** List of additional log fields managed in this log kind */
+export type IpLoadbalancingLdpKindLdpKindAdditionalReturnedFieldsList = Array<string>;
+export declare const IpLoadbalancingLdpKindLdpKindAdditionalReturnedFieldsList: S.Schema<IpLoadbalancingLdpKindLdpKindAdditionalReturnedFieldsList>;
+/** Log kind for your Load Balancer */
+export interface IpLoadbalancingLdpKindLdpKind {
+    /** List of additional log fields managed in this log kind */
+    additionalReturnedFields?: IpLoadbalancingLdpKindLdpKindAdditionalReturnedFieldsList;
+    /** Creation date of the log kind */
+    createdAt?: string;
+    /** Log kind display name */
+    displayName?: string;
+    /** Log kind ID */
+    kindId?: string;
+    /** Log kind name */
+    name?: string;
+    /** Last update date of the log kind */
+    updatedAt?: string;
+}
+export declare const IpLoadbalancingLdpKindLdpKind: S.Schema<IpLoadbalancingLdpKindLdpKind>;
+export interface GetIpLoadbalancingLogSubscriptionRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const GetIpLoadbalancingLogSubscriptionRequest: S.Schema<GetIpLoadbalancingLogSubscriptionRequest>;
+/** Logs subscription resource for your Load Balancer */
+export interface IpLoadbalancingLogSubscriptionResource {
+    /** Name of subscribed resource */
+    name?: string;
+    /** Type of subscribed resource */
+    type?: string;
+}
+export declare const IpLoadbalancingLogSubscriptionResource: S.Schema<IpLoadbalancingLogSubscriptionResource>;
+/** Log subscription for your Load Balancer */
+export interface IpLoadbalancingLdpSubscriptionLdpSubscription {
+    /** Creation date of the subscription */
+    createdAt?: string;
+    /** Log kind name of this subscription */
+    kind?: string;
+    /** Subscribed resource, where the logs come from */
+    resource?: IpLoadbalancingLogSubscriptionResource;
+    /** Name of the destination log service */
+    serviceName?: string;
+    /** Id of the destination log stream */
+    streamId?: string;
+    /** Subscription ID */
+    subscriptionId?: string;
+    /** Last update date of the subscription */
+    updatedAt?: string;
+}
+export declare const IpLoadbalancingLdpSubscriptionLdpSubscription: S.Schema<IpLoadbalancingLdpSubscriptionLdpSubscription>;
+export interface GetIpLoadbalancingMetricsTokenRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const GetIpLoadbalancingMetricsTokenRequest: S.Schema<GetIpLoadbalancingMetricsTokenRequest>;
+/** The metrics token of a Load Balancer */
+export interface IpLoadbalancingMetricsToken {
+    /** The metrics endpoint */
+    endpoint?: string;
+    /** The metrics token */
+    token?: string;
+}
+export declare const IpLoadbalancingMetricsToken: S.Schema<IpLoadbalancingMetricsToken>;
+export interface GetIpLoadbalancingQuotaRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Zone of your quota */
+    zone: string;
+}
+export declare const GetIpLoadbalancingQuotaRequest: S.Schema<GetIpLoadbalancingQuotaRequest>;
+/** Quota informations for current billing period for this zone */
+export interface IpLoadbalancingQuotaQuota {
+    /** Quota alert value in bytes. When reached, we will send you an alert. Default : included quota with your offer */
+    alert?: number | null;
+    /** Included quota value with your offer, in bytes */
+    included?: number | null;
+    /** The last time your quota was updated from your Load Balancer instance */
+    lastUpdateDate?: string | null;
+    /** The last time your quota was resetted (billed) */
+    resetDate?: string | null;
+    /** Total used quota value in bytes */
+    total?: number | null;
+    /** Zone of your quota */
+    zone?: string;
+}
+export declare const IpLoadbalancingQuotaQuota: S.Schema<IpLoadbalancingQuotaQuota>;
+export interface GetIpLoadbalancingQuotaHistoryRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your quota */
+    id: number;
+}
+export declare const GetIpLoadbalancingQuotaHistoryRequest: S.Schema<GetIpLoadbalancingQuotaHistoryRequest>;
+/** QuotaHistory */
+export interface IpLoadbalancingQuotaHistoryQuotaHistory {
+    /** Historized date for this quota entry */
+    historizedDate?: string;
+    /** Id of your quota */
+    id?: number;
+    /** The last time your quota was updated from your Load Balancer instance */
+    lastUpdateDate?: string;
+    /** The last time your quota was resetted (billed) */
+    resetDate?: string;
+    /** Total used quota value in bytes */
+    total?: number;
+    /** Zone of your quota */
+    zone?: string;
+}
+export declare const IpLoadbalancingQuotaHistoryQuotaHistory: S.Schema<IpLoadbalancingQuotaHistoryQuotaHistory>;
+export interface GetIpLoadbalancingServiceInfosRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const GetIpLoadbalancingServiceInfosRequest: S.Schema<GetIpLoadbalancingServiceInfosRequest>;
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export declare const ServicesServicePossibleRenewPeriodList: S.Schema<ServicesServicePossibleRenewPeriodList>;
+/** Map a possible renew for a specific service */
+export interface ServiceRenewType {
+    /** The service is automatically renewed */
+    automatic?: boolean;
+    /** The service will be deleted at expiration */
+    deleteAtExpiration?: boolean;
+    /** The service forced to be renewed */
+    forced?: boolean;
+    /** The service needs to be manually renewed and paid */
+    manualPayment?: boolean | null;
+    /** period of renew in month */
+    period?: number | null;
+}
+export declare const ServiceRenewType: S.Schema<ServiceRenewType>;
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum = "automaticForcedProduct" | "automaticV2012" | "automaticV2014" | "automaticV2016" | "automaticV2024" | "manual" | "oneShot" | "option";
+export declare const ServiceRenewalTypeEnum: any;
+export type ServiceStateEnum = "autorenewInProgress" | "expired" | "inCreation" | "ok" | "pendingDebt" | "unPaid";
+export declare const ServiceStateEnum: any;
+/** Details about a Service */
+export interface ServicesService {
+    /** Indicates that the service can be set up to be deleted at expiration */
+    canDeleteAtExpiration?: boolean;
+    contactAdmin?: string;
+    contactBilling?: string;
+    contactTech?: string;
+    creation?: string;
+    domain?: string;
+    engagedUpTo?: string | null;
+    expiration?: string;
+    /** All the possible renew period of your service in month */
+    possibleRenewPeriod?: ServicesServicePossibleRenewPeriodList | null;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+    renewalType?: ServiceRenewalTypeEnum;
+    serviceId?: number;
+    status?: ServiceStateEnum;
+}
+export declare const ServicesService: S.Schema<ServicesService>;
+export interface GetIpLoadbalancingSslRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your SSL certificate */
+    id: number;
+}
+export declare const GetIpLoadbalancingSslRequest: S.Schema<GetIpLoadbalancingSslRequest>;
+export interface GetIpLoadbalancingStatusRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const GetIpLoadbalancingStatusRequest: S.Schema<GetIpLoadbalancingStatusRequest>;
+/** The statuses of a Load Balancer component */
+export interface IpLoadbalancingStatusComponentStatus {
+    /** The number of component with status error */
+    error?: number;
+    /** The number of component with status ok */
+    ok?: number;
+    /** The number of component with status unknown */
+    unknown?: number;
+    /** The number of component with status warn */
+    warn?: number;
+}
+export declare const IpLoadbalancingStatusComponentStatus: S.Schema<IpLoadbalancingStatusComponentStatus>;
+/** The global status of a Load Balancer component */
+export interface IpLoadbalancingStatusComponent {
+    /** The global status of your Load Balancer component */
+    status?: IpLoadbalancingStatusComponentStatus;
+    /** The Load Balancer total component count */
+    total?: number;
+}
+export declare const IpLoadbalancingStatusComponent: S.Schema<IpLoadbalancingStatusComponent>;
+/** Possible values for a Load Balancer status */
+export type IpLoadbalancingStatusEnum = "error" | "ok" | "unknown" | "warn";
+export declare const IpLoadbalancingStatusEnum: any;
+/** The status of a Load Balancer service */
+export interface IpLoadbalancingStatusService {
+    /** The status of your Load Balancer billing domain */
+    status?: IpLoadbalancingStatusEnum;
+}
+export declare const IpLoadbalancingStatusService: S.Schema<IpLoadbalancingStatusService>;
+/** The global status of a Load Balancer */
+export interface IpLoadbalancingStatus {
+    /** The Load Balancer farms status informations */
+    farms?: IpLoadbalancingStatusComponent;
+    /** The Load Balancer frontends status informations */
+    frontends?: IpLoadbalancingStatusComponent;
+    /** The Load Balancer servers status informations */
+    servers?: IpLoadbalancingStatusComponent;
+    /** The Load Balancer service status informations */
+    service?: IpLoadbalancingStatusService;
+}
+export declare const IpLoadbalancingStatus: S.Schema<IpLoadbalancingStatus>;
+export interface GetIpLoadbalancingTaskRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of the operation */
+    id: number;
+}
+export declare const GetIpLoadbalancingTaskRequest: S.Schema<GetIpLoadbalancingTaskRequest>;
+export interface GetIpLoadbalancingTcpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+}
+export declare const GetIpLoadbalancingTcpFarmRequest: S.Schema<GetIpLoadbalancingTcpFarmRequest>;
+export interface GetIpLoadbalancingTcpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+}
+export declare const GetIpLoadbalancingTcpFarmServerRequest: S.Schema<GetIpLoadbalancingTcpFarmServerRequest>;
+export interface GetIpLoadbalancingTcpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    transparentId: number;
+}
+export declare const GetIpLoadbalancingTcpFarmServerTransparentRequest: S.Schema<GetIpLoadbalancingTcpFarmServerTransparentRequest>;
+export interface GetIpLoadbalancingTcpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+}
+export declare const GetIpLoadbalancingTcpFrontendRequest: S.Schema<GetIpLoadbalancingTcpFrontendRequest>;
+export interface GetIpLoadbalancingTcpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+}
+export declare const GetIpLoadbalancingTcpRouteRequest: S.Schema<GetIpLoadbalancingTcpRouteRequest>;
+export interface GetIpLoadbalancingTcpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Id of your rule */
+    ruleId: number;
+}
+export declare const GetIpLoadbalancingTcpRouteRuleRequest: S.Schema<GetIpLoadbalancingTcpRouteRuleRequest>;
+export interface GetIpLoadbalancingUdpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+}
+export declare const GetIpLoadbalancingUdpFarmRequest: S.Schema<GetIpLoadbalancingUdpFarmRequest>;
+export interface GetIpLoadbalancingUdpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+}
+export declare const GetIpLoadbalancingUdpFarmServerRequest: S.Schema<GetIpLoadbalancingUdpFarmServerRequest>;
+export interface GetIpLoadbalancingUdpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+}
+export declare const GetIpLoadbalancingUdpFrontendRequest: S.Schema<GetIpLoadbalancingUdpFrontendRequest>;
+export interface GetIpLoadbalancingVrackNetworkRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Internal Load Balancer identifier of the vRack private network description */
+    vrackNetworkId: number;
+}
+export declare const GetIpLoadbalancingVrackNetworkRequest: S.Schema<GetIpLoadbalancingVrackNetworkRequest>;
+export interface GetIpLoadbalancingVrackNetworkCreationRulesRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const GetIpLoadbalancingVrackNetworkCreationRulesRequest: S.Schema<GetIpLoadbalancingVrackNetworkCreationRulesRequest>;
+/** Rules to create a new description of a private network in the vRack */
+export interface IpLoadbalancingVrackNetworkCreationRules {
+    /** Minimum number of IPs needed to forward requests to your servers using NAT in your private network behind the current Load Balancer. Ip Block given on Load Balancer vRack network must contain at least this number of IP. */
+    minNatIps?: number;
+    /** Number of remaining private network descriptions available for creation for this Load Balancer */
+    remainingNetworks?: number;
+    /** Name of the vRack on which the current Load Balancer is attached to, as it is named on vRack product */
+    vrackName?: string;
+}
+export declare const IpLoadbalancingVrackNetworkCreationRules: S.Schema<IpLoadbalancingVrackNetworkCreationRules>;
+export interface GetIpLoadbalancingZoneRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Name of your zone */
+    name: string;
+}
+export declare const GetIpLoadbalancingZoneRequest: S.Schema<GetIpLoadbalancingZoneRequest>;
+/** IP Load Balancing Zone */
+export interface IpLoadbalancingZoneZone {
+    /** Name of your zone */
+    name?: string;
+    /** State of your zone */
+    state?: string;
+}
+export declare const IpLoadbalancingZoneZone: S.Schema<IpLoadbalancingZoneZone>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListIpLoadbalancingRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListIpLoadbalancingRequestIamTagsValueList: S.Schema<ListIpLoadbalancingRequestIamTagsValueList>;
+export type ListIpLoadbalancingRequestIamTagsMap = {
+    [key: string]: ListIpLoadbalancingRequestIamTagsValueList | undefined;
+};
+export declare const ListIpLoadbalancingRequestIamTagsMap: S.Schema<ListIpLoadbalancingRequestIamTagsMap>;
+export interface ListIpLoadbalancingRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListIpLoadbalancingRequestIamTagsMap;
+}
+export declare const ListIpLoadbalancingRequest: S.Schema<ListIpLoadbalancingRequest>;
+export type ListIpLoadbalancingResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingResponseBodyList: S.Schema<ListIpLoadbalancingResponseBodyList>;
+export type ListIpLoadbalancingResponse = ListIpLoadbalancingResponseBodyList;
+export declare const ListIpLoadbalancingResponse: S.Schema<ListIpLoadbalancingResponse>;
+export interface ListIpLoadbalancingAvailableFarmProbesRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingAvailableFarmProbesRequest: S.Schema<ListIpLoadbalancingAvailableFarmProbesRequest>;
+/** List of possible probe result checkers for this type of probe */
+export type IpLoadbalancingFarmAvailableProbeMatchesList = Array<string>;
+export declare const IpLoadbalancingFarmAvailableProbeMatchesList: S.Schema<IpLoadbalancingFarmAvailableProbeMatchesList>;
+/** List of available HTTP method, if available */
+export type IpLoadbalancingFarmAvailableProbeMethodList = Array<string>;
+export declare const IpLoadbalancingFarmAvailableProbeMethodList: S.Schema<IpLoadbalancingFarmAvailableProbeMethodList>;
+/** List of matches operators that accept the negate option for this type of probe */
+export type IpLoadbalancingFarmAvailableProbeNegatableMatchesList = Array<string>;
+export declare const IpLoadbalancingFarmAvailableProbeNegatableMatchesList: S.Schema<IpLoadbalancingFarmAvailableProbeNegatableMatchesList>;
+/** Available farm probes options */
+export interface IpLoadbalancingFarmAvailableProbe {
+    /** List of possible probe result checkers for this type of probe */
+    matches?: IpLoadbalancingFarmAvailableProbeMatchesList;
+    /** List of available HTTP method, if available */
+    method?: IpLoadbalancingFarmAvailableProbeMethodList | null;
+    /** List of matches operators that accept the negate option for this type of probe */
+    negatableMatches?: IpLoadbalancingFarmAvailableProbeNegatableMatchesList;
+    /** True is this probe type supports a custom port */
+    port?: boolean;
+    /** Probe protocol name. See probe "type" field in the farm probe */
+    type?: string;
+    /** True is this probe type supports a URL */
+    url?: boolean;
+}
+export declare const IpLoadbalancingFarmAvailableProbe: S.Schema<IpLoadbalancingFarmAvailableProbe>;
+export type ListIpLoadbalancingAvailableFarmProbesResponseBodyList = Array<IpLoadbalancingFarmAvailableProbe>;
+export declare const ListIpLoadbalancingAvailableFarmProbesResponseBodyList: S.Schema<ListIpLoadbalancingAvailableFarmProbesResponseBodyList>;
+export type ListIpLoadbalancingAvailableFarmProbesResponse = ListIpLoadbalancingAvailableFarmProbesResponseBodyList;
+export declare const ListIpLoadbalancingAvailableFarmProbesResponse: S.Schema<ListIpLoadbalancingAvailableFarmProbesResponse>;
+export interface ListIpLoadbalancingAvailableFarmTypeRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingAvailableFarmTypeRequest: S.Schema<ListIpLoadbalancingAvailableFarmTypeRequest>;
+export type ListIpLoadbalancingAvailableFarmTypeResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingAvailableFarmTypeResponseBodyList: S.Schema<ListIpLoadbalancingAvailableFarmTypeResponseBodyList>;
+export type ListIpLoadbalancingAvailableFarmTypeResponse = ListIpLoadbalancingAvailableFarmTypeResponseBodyList;
+export declare const ListIpLoadbalancingAvailableFarmTypeResponse: S.Schema<ListIpLoadbalancingAvailableFarmTypeResponse>;
+export interface ListIpLoadbalancingAvailableFrontendTypeRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingAvailableFrontendTypeRequest: S.Schema<ListIpLoadbalancingAvailableFrontendTypeRequest>;
+export type ListIpLoadbalancingAvailableFrontendTypeResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingAvailableFrontendTypeResponseBodyList: S.Schema<ListIpLoadbalancingAvailableFrontendTypeResponseBodyList>;
+export type ListIpLoadbalancingAvailableFrontendTypeResponse = ListIpLoadbalancingAvailableFrontendTypeResponseBodyList;
+export declare const ListIpLoadbalancingAvailableFrontendTypeResponse: S.Schema<ListIpLoadbalancingAvailableFrontendTypeResponse>;
+export interface ListIpLoadbalancingAvailableRouteActionsRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingAvailableRouteActionsRequest: S.Schema<ListIpLoadbalancingAvailableRouteActionsRequest>;
+/** List of available HTTP status code if applicable */
+export type IpLoadbalancingRouteAvailableActionStatusList = Array<number>;
+export declare const IpLoadbalancingRouteAvailableActionStatusList: S.Schema<IpLoadbalancingRouteAvailableActionStatusList>;
+/** Available route actions options */
+export interface IpLoadbalancingRouteAvailableAction {
+    /** Type of the destination for this action */
+    destination?: string | null;
+    /** Action name */
+    name?: string;
+    /** List of available HTTP status code if applicable */
+    status?: IpLoadbalancingRouteAvailableActionStatusList | null;
+    /** Protocol supported by this action */
+    type?: string;
+}
+export declare const IpLoadbalancingRouteAvailableAction: S.Schema<IpLoadbalancingRouteAvailableAction>;
+export type ListIpLoadbalancingAvailableRouteActionsResponseBodyList = Array<IpLoadbalancingRouteAvailableAction>;
+export declare const ListIpLoadbalancingAvailableRouteActionsResponseBodyList: S.Schema<ListIpLoadbalancingAvailableRouteActionsResponseBodyList>;
+export type ListIpLoadbalancingAvailableRouteActionsResponse = ListIpLoadbalancingAvailableRouteActionsResponseBodyList;
+export declare const ListIpLoadbalancingAvailableRouteActionsResponse: S.Schema<ListIpLoadbalancingAvailableRouteActionsResponse>;
+export interface ListIpLoadbalancingAvailableRouteRulesRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingAvailableRouteRulesRequest: S.Schema<ListIpLoadbalancingAvailableRouteRulesRequest>;
+/** If pattern is "enum", list of available options */
+export type IpLoadbalancingRouteAvailableRuleEnumList = Array<string>;
+export declare const IpLoadbalancingRouteAvailableRuleEnumList: S.Schema<IpLoadbalancingRouteAvailableRuleEnumList>;
+/** List of match operators compatible with this rule */
+export type IpLoadbalancingRouteAvailableRuleMatchesList = Array<string>;
+export declare const IpLoadbalancingRouteAvailableRuleMatchesList: S.Schema<IpLoadbalancingRouteAvailableRuleMatchesList>;
+/** Match rule to combine to build routes */
+export interface IpLoadbalancingRouteAvailableRule {
+    /** If pattern is "enum", list of available options */
+    enum?: IpLoadbalancingRouteAvailableRuleEnumList | null;
+    /** If true, this rule needs a subfield. Typically a cookie or header name */
+    hasSubField?: boolean;
+    /** List of match operators compatible with this rule */
+    matches?: IpLoadbalancingRouteAvailableRuleMatchesList;
+    /** Rule name */
+    name?: string;
+    /** Expected type for the pattern. Like "enum", "backend", "cidr", ... */
+    pattern?: string;
+    /** Protocol supported by this action */
+    type?: string;
+}
+export declare const IpLoadbalancingRouteAvailableRule: S.Schema<IpLoadbalancingRouteAvailableRule>;
+export type ListIpLoadbalancingAvailableRouteRulesResponseBodyList = Array<IpLoadbalancingRouteAvailableRule>;
+export declare const ListIpLoadbalancingAvailableRouteRulesResponseBodyList: S.Schema<ListIpLoadbalancingAvailableRouteRulesResponseBodyList>;
+export type ListIpLoadbalancingAvailableRouteRulesResponse = ListIpLoadbalancingAvailableRouteRulesResponseBodyList;
+export declare const ListIpLoadbalancingAvailableRouteRulesResponse: S.Schema<ListIpLoadbalancingAvailableRouteRulesResponse>;
+export interface ListIpLoadbalancingDefinedFarmsRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** The vrack network id you want to filter on */
+    vrackNetworkId?: number;
+}
+export declare const ListIpLoadbalancingDefinedFarmsRequest: S.Schema<ListIpLoadbalancingDefinedFarmsRequest>;
+export type ListIpLoadbalancingDefinedFarmsResponseBodyList = Array<IpLoadbalancingDefinedFarm>;
+export declare const ListIpLoadbalancingDefinedFarmsResponseBodyList: S.Schema<ListIpLoadbalancingDefinedFarmsResponseBodyList>;
+export type ListIpLoadbalancingDefinedFarmsResponse = ListIpLoadbalancingDefinedFarmsResponseBodyList;
+export declare const ListIpLoadbalancingDefinedFarmsResponse: S.Schema<ListIpLoadbalancingDefinedFarmsResponse>;
+export interface ListIpLoadbalancingDefinedFrontendsRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingDefinedFrontendsRequest: S.Schema<ListIpLoadbalancingDefinedFrontendsRequest>;
+/** a list of {type=>[Frontend ids]} */
+export type IpLoadbalancingDefinedFrontend = IpLoadbalancingDefinedFarm;
+export declare const IpLoadbalancingDefinedFrontend: S.Schema<IpLoadbalancingDefinedFarm>;
+export type ListIpLoadbalancingDefinedFrontendsResponseBodyList = Array<IpLoadbalancingDefinedFarm>;
+export declare const ListIpLoadbalancingDefinedFrontendsResponseBodyList: S.Schema<ListIpLoadbalancingDefinedFrontendsResponseBodyList>;
+export type ListIpLoadbalancingDefinedFrontendsResponse = ListIpLoadbalancingDefinedFrontendsResponseBodyList;
+export declare const ListIpLoadbalancingDefinedFrontendsResponse: S.Schema<ListIpLoadbalancingDefinedFrontendsResponse>;
+export interface ListIpLoadbalancingDefinedRoutesRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingDefinedRoutesRequest: S.Schema<ListIpLoadbalancingDefinedRoutesRequest>;
+/** Defined routes name, type and id. Typically used to generate autocomplete lists. */
+export interface IpLoadbalancingDefinedRoute {
+    /** Human readable name for your route */
+    displayName?: string | null;
+    /** Id of your route */
+    routeId?: number;
+    /** Protocol supported by this route */
+    type?: string;
+}
+export declare const IpLoadbalancingDefinedRoute: S.Schema<IpLoadbalancingDefinedRoute>;
+export type ListIpLoadbalancingDefinedRoutesResponseBodyList = Array<IpLoadbalancingDefinedRoute>;
+export declare const ListIpLoadbalancingDefinedRoutesResponseBodyList: S.Schema<ListIpLoadbalancingDefinedRoutesResponseBodyList>;
+export type ListIpLoadbalancingDefinedRoutesResponse = ListIpLoadbalancingDefinedRoutesResponseBodyList;
+export declare const ListIpLoadbalancingDefinedRoutesResponse: S.Schema<ListIpLoadbalancingDefinedRoutesResponse>;
+export interface ListIpLoadbalancingFailoverRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingFailoverRequest: S.Schema<ListIpLoadbalancingFailoverRequest>;
+export type ListIpLoadbalancingFailoverResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingFailoverResponseBodyList: S.Schema<ListIpLoadbalancingFailoverResponseBodyList>;
+export type ListIpLoadbalancingFailoverResponse = ListIpLoadbalancingFailoverResponseBodyList;
+export declare const ListIpLoadbalancingFailoverResponse: S.Schema<ListIpLoadbalancingFailoverResponse>;
+export interface ListIpLoadbalancingHttpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of vrackNetworkId property (=) */
+    vrackNetworkId?: number;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingHttpFarmRequest: S.Schema<ListIpLoadbalancingHttpFarmRequest>;
+export type ListIpLoadbalancingHttpFarmResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingHttpFarmResponseBodyList: S.Schema<ListIpLoadbalancingHttpFarmResponseBodyList>;
+export type ListIpLoadbalancingHttpFarmResponse = ListIpLoadbalancingHttpFarmResponseBodyList;
+export declare const ListIpLoadbalancingHttpFarmResponse: S.Schema<ListIpLoadbalancingHttpFarmResponse>;
+export interface ListIpLoadbalancingHttpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Filter the value of address property (=) */
+    address?: string;
+    /** Filter the value of cookie property (like) */
+    cookie?: string;
+    /** Filter the value of status property (=) */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+}
+export declare const ListIpLoadbalancingHttpFarmServerRequest: S.Schema<ListIpLoadbalancingHttpFarmServerRequest>;
+export type ListIpLoadbalancingHttpFarmServerResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingHttpFarmServerResponseBodyList: S.Schema<ListIpLoadbalancingHttpFarmServerResponseBodyList>;
+export type ListIpLoadbalancingHttpFarmServerResponse = ListIpLoadbalancingHttpFarmServerResponseBodyList;
+export declare const ListIpLoadbalancingHttpFarmServerResponse: S.Schema<ListIpLoadbalancingHttpFarmServerResponse>;
+export interface ListIpLoadbalancingHttpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    /** Filter the value of slotId property (=) */
+    slotId?: number;
+}
+export declare const ListIpLoadbalancingHttpFarmServerTransparentRequest: S.Schema<ListIpLoadbalancingHttpFarmServerTransparentRequest>;
+export type ListIpLoadbalancingHttpFarmServerTransparentResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingHttpFarmServerTransparentResponseBodyList: S.Schema<ListIpLoadbalancingHttpFarmServerTransparentResponseBodyList>;
+export type ListIpLoadbalancingHttpFarmServerTransparentResponse = ListIpLoadbalancingHttpFarmServerTransparentResponseBodyList;
+export declare const ListIpLoadbalancingHttpFarmServerTransparentResponse: S.Schema<ListIpLoadbalancingHttpFarmServerTransparentResponse>;
+export interface ListIpLoadbalancingHttpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of defaultFarmId property (=) */
+    defaultFarmId?: number;
+    /** Filter the value of defaultSslId property (=) */
+    defaultSslId?: number;
+    /** Filter the value of port property (like) */
+    port?: string;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingHttpFrontendRequest: S.Schema<ListIpLoadbalancingHttpFrontendRequest>;
+export type ListIpLoadbalancingHttpFrontendResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingHttpFrontendResponseBodyList: S.Schema<ListIpLoadbalancingHttpFrontendResponseBodyList>;
+export type ListIpLoadbalancingHttpFrontendResponse = ListIpLoadbalancingHttpFrontendResponseBodyList;
+export declare const ListIpLoadbalancingHttpFrontendResponse: S.Schema<ListIpLoadbalancingHttpFrontendResponse>;
+export interface ListIpLoadbalancingHttpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of frontendId property (=) */
+    frontendId?: number;
+}
+export declare const ListIpLoadbalancingHttpRouteRequest: S.Schema<ListIpLoadbalancingHttpRouteRequest>;
+export type ListIpLoadbalancingHttpRouteResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingHttpRouteResponseBodyList: S.Schema<ListIpLoadbalancingHttpRouteResponseBodyList>;
+export type ListIpLoadbalancingHttpRouteResponse = ListIpLoadbalancingHttpRouteResponseBodyList;
+export declare const ListIpLoadbalancingHttpRouteResponse: S.Schema<ListIpLoadbalancingHttpRouteResponse>;
+export interface ListIpLoadbalancingHttpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+}
+export declare const ListIpLoadbalancingHttpRouteRuleRequest: S.Schema<ListIpLoadbalancingHttpRouteRuleRequest>;
+export type ListIpLoadbalancingHttpRouteRuleResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingHttpRouteRuleResponseBodyList: S.Schema<ListIpLoadbalancingHttpRouteRuleResponseBodyList>;
+export type ListIpLoadbalancingHttpRouteRuleResponse = ListIpLoadbalancingHttpRouteRuleResponseBodyList;
+export declare const ListIpLoadbalancingHttpRouteRuleResponse: S.Schema<ListIpLoadbalancingHttpRouteRuleResponse>;
+export interface ListIpLoadbalancingLogKindRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingLogKindRequest: S.Schema<ListIpLoadbalancingLogKindRequest>;
+export type ListIpLoadbalancingLogKindResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingLogKindResponseBodyList: S.Schema<ListIpLoadbalancingLogKindResponseBodyList>;
+export type ListIpLoadbalancingLogKindResponse = ListIpLoadbalancingLogKindResponseBodyList;
+export declare const ListIpLoadbalancingLogKindResponse: S.Schema<ListIpLoadbalancingLogKindResponse>;
+export interface ListIpLoadbalancingLogSubscriptionRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of kind property (=) */
+    kind?: string;
+}
+export declare const ListIpLoadbalancingLogSubscriptionRequest: S.Schema<ListIpLoadbalancingLogSubscriptionRequest>;
+export type ListIpLoadbalancingLogSubscriptionResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingLogSubscriptionResponseBodyList: S.Schema<ListIpLoadbalancingLogSubscriptionResponseBodyList>;
+export type ListIpLoadbalancingLogSubscriptionResponse = ListIpLoadbalancingLogSubscriptionResponseBodyList;
+export declare const ListIpLoadbalancingLogSubscriptionResponse: S.Schema<ListIpLoadbalancingLogSubscriptionResponse>;
+export interface ListIpLoadbalancingNatIpRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingNatIpRequest: S.Schema<ListIpLoadbalancingNatIpRequest>;
+export type IpLoadbalancingNatIpsIpList = Array<string>;
+export declare const IpLoadbalancingNatIpsIpList: S.Schema<IpLoadbalancingNatIpsIpList>;
+/** a list of {zone, nat Ip} */
+export interface IpLoadbalancingNatIps {
+    ip?: IpLoadbalancingNatIpsIpList;
+    zone?: string;
+}
+export declare const IpLoadbalancingNatIps: S.Schema<IpLoadbalancingNatIps>;
+export type ListIpLoadbalancingNatIpResponseBodyList = Array<IpLoadbalancingNatIps>;
+export declare const ListIpLoadbalancingNatIpResponseBodyList: S.Schema<ListIpLoadbalancingNatIpResponseBodyList>;
+export type ListIpLoadbalancingNatIpResponse = ListIpLoadbalancingNatIpResponseBodyList;
+export declare const ListIpLoadbalancingNatIpResponse: S.Schema<ListIpLoadbalancingNatIpResponse>;
+export interface ListIpLoadbalancingPendingChangesRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingPendingChangesRequest: S.Schema<ListIpLoadbalancingPendingChangesRequest>;
+/** The pending changes for a Load Balancer zone */
+export interface IpLoadbalancingPendingChanges {
+    /** The number of changes waiting to be applied */
+    number?: number;
+    /** The Load Balancer zone with pending changes */
+    zone?: string;
+}
+export declare const IpLoadbalancingPendingChanges: S.Schema<IpLoadbalancingPendingChanges>;
+export type ListIpLoadbalancingPendingChangesResponseBodyList = Array<IpLoadbalancingPendingChanges>;
+export declare const ListIpLoadbalancingPendingChangesResponseBodyList: S.Schema<ListIpLoadbalancingPendingChangesResponseBodyList>;
+export type ListIpLoadbalancingPendingChangesResponse = ListIpLoadbalancingPendingChangesResponseBodyList;
+export declare const ListIpLoadbalancingPendingChangesResponse: S.Schema<ListIpLoadbalancingPendingChangesResponse>;
+export interface ListIpLoadbalancingQuotaRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingQuotaRequest: S.Schema<ListIpLoadbalancingQuotaRequest>;
+export type ListIpLoadbalancingQuotaResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingQuotaResponseBodyList: S.Schema<ListIpLoadbalancingQuotaResponseBodyList>;
+export type ListIpLoadbalancingQuotaResponse = ListIpLoadbalancingQuotaResponseBodyList;
+export declare const ListIpLoadbalancingQuotaResponse: S.Schema<ListIpLoadbalancingQuotaResponse>;
+export interface ListIpLoadbalancingQuotaHistoryRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of historizedDate property (>=) */
+    historizedDate_from?: string;
+    /** Filter the value of historizedDate property (<=) */
+    historizedDate_to?: string;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingQuotaHistoryRequest: S.Schema<ListIpLoadbalancingQuotaHistoryRequest>;
+export type ListIpLoadbalancingQuotaHistoryResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingQuotaHistoryResponseBodyList: S.Schema<ListIpLoadbalancingQuotaHistoryResponseBodyList>;
+export type ListIpLoadbalancingQuotaHistoryResponse = ListIpLoadbalancingQuotaHistoryResponseBodyList;
+export declare const ListIpLoadbalancingQuotaHistoryResponse: S.Schema<ListIpLoadbalancingQuotaHistoryResponse>;
+export interface ListIpLoadbalancingSslRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of expireDate property (<) */
+    expireDate?: string;
+    /** Filter the value of fingerprint property (like) */
+    fingerprint?: string;
+    /** Filter the value of serial property (like) */
+    serial?: string;
+    /** Filter the value of type property (=) */
+    type?: IpLoadbalancingSslTypeEnum | (string & {});
+}
+export declare const ListIpLoadbalancingSslRequest: S.Schema<ListIpLoadbalancingSslRequest>;
+export type ListIpLoadbalancingSslResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingSslResponseBodyList: S.Schema<ListIpLoadbalancingSslResponseBodyList>;
+export type ListIpLoadbalancingSslResponse = ListIpLoadbalancingSslResponseBodyList;
+export declare const ListIpLoadbalancingSslResponse: S.Schema<ListIpLoadbalancingSslResponse>;
+export interface ListIpLoadbalancingTaskRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of action property (=) */
+    action?: IpLoadbalancingTaskActionEnum | (string & {});
+    /** Filter the value of creationDate property (>=) */
+    creationDate_from?: string;
+    /** Filter the value of creationDate property (<=) */
+    creationDate_to?: string;
+    /** Filter the value of doneDate property (>=) */
+    doneDate_from?: string;
+    /** Filter the value of doneDate property (<=) */
+    doneDate_to?: string;
+    /** Filter the value of status property (=) */
+    status?: IpLoadbalancingTaskStatusEnum | (string & {});
+}
+export declare const ListIpLoadbalancingTaskRequest: S.Schema<ListIpLoadbalancingTaskRequest>;
+export type ListIpLoadbalancingTaskResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTaskResponseBodyList: S.Schema<ListIpLoadbalancingTaskResponseBodyList>;
+export type ListIpLoadbalancingTaskResponse = ListIpLoadbalancingTaskResponseBodyList;
+export declare const ListIpLoadbalancingTaskResponse: S.Schema<ListIpLoadbalancingTaskResponse>;
+export interface ListIpLoadbalancingTcpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of vrackNetworkId property (=) */
+    vrackNetworkId?: number;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingTcpFarmRequest: S.Schema<ListIpLoadbalancingTcpFarmRequest>;
+export type ListIpLoadbalancingTcpFarmResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTcpFarmResponseBodyList: S.Schema<ListIpLoadbalancingTcpFarmResponseBodyList>;
+export type ListIpLoadbalancingTcpFarmResponse = ListIpLoadbalancingTcpFarmResponseBodyList;
+export declare const ListIpLoadbalancingTcpFarmResponse: S.Schema<ListIpLoadbalancingTcpFarmResponse>;
+export interface ListIpLoadbalancingTcpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Filter the value of address property (=) */
+    address?: string;
+    /** Filter the value of status property (=) */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+}
+export declare const ListIpLoadbalancingTcpFarmServerRequest: S.Schema<ListIpLoadbalancingTcpFarmServerRequest>;
+export type ListIpLoadbalancingTcpFarmServerResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTcpFarmServerResponseBodyList: S.Schema<ListIpLoadbalancingTcpFarmServerResponseBodyList>;
+export type ListIpLoadbalancingTcpFarmServerResponse = ListIpLoadbalancingTcpFarmServerResponseBodyList;
+export declare const ListIpLoadbalancingTcpFarmServerResponse: S.Schema<ListIpLoadbalancingTcpFarmServerResponse>;
+export interface ListIpLoadbalancingTcpFarmServerTransparentRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    /** Filter the value of slotId property (=) */
+    slotId?: number;
+}
+export declare const ListIpLoadbalancingTcpFarmServerTransparentRequest: S.Schema<ListIpLoadbalancingTcpFarmServerTransparentRequest>;
+export type ListIpLoadbalancingTcpFarmServerTransparentResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTcpFarmServerTransparentResponseBodyList: S.Schema<ListIpLoadbalancingTcpFarmServerTransparentResponseBodyList>;
+export type ListIpLoadbalancingTcpFarmServerTransparentResponse = ListIpLoadbalancingTcpFarmServerTransparentResponseBodyList;
+export declare const ListIpLoadbalancingTcpFarmServerTransparentResponse: S.Schema<ListIpLoadbalancingTcpFarmServerTransparentResponse>;
+export interface ListIpLoadbalancingTcpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of defaultFarmId property (=) */
+    defaultFarmId?: number;
+    /** Filter the value of defaultSslId property (=) */
+    defaultSslId?: number;
+    /** Filter the value of port property (like) */
+    port?: string;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingTcpFrontendRequest: S.Schema<ListIpLoadbalancingTcpFrontendRequest>;
+export type ListIpLoadbalancingTcpFrontendResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTcpFrontendResponseBodyList: S.Schema<ListIpLoadbalancingTcpFrontendResponseBodyList>;
+export type ListIpLoadbalancingTcpFrontendResponse = ListIpLoadbalancingTcpFrontendResponseBodyList;
+export declare const ListIpLoadbalancingTcpFrontendResponse: S.Schema<ListIpLoadbalancingTcpFrontendResponse>;
+export interface ListIpLoadbalancingTcpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of frontendId property (=) */
+    frontendId?: number;
+}
+export declare const ListIpLoadbalancingTcpRouteRequest: S.Schema<ListIpLoadbalancingTcpRouteRequest>;
+export type ListIpLoadbalancingTcpRouteResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTcpRouteResponseBodyList: S.Schema<ListIpLoadbalancingTcpRouteResponseBodyList>;
+export type ListIpLoadbalancingTcpRouteResponse = ListIpLoadbalancingTcpRouteResponseBodyList;
+export declare const ListIpLoadbalancingTcpRouteResponse: S.Schema<ListIpLoadbalancingTcpRouteResponse>;
+export interface ListIpLoadbalancingTcpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+}
+export declare const ListIpLoadbalancingTcpRouteRuleRequest: S.Schema<ListIpLoadbalancingTcpRouteRuleRequest>;
+export type ListIpLoadbalancingTcpRouteRuleResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingTcpRouteRuleResponseBodyList: S.Schema<ListIpLoadbalancingTcpRouteRuleResponseBodyList>;
+export type ListIpLoadbalancingTcpRouteRuleResponse = ListIpLoadbalancingTcpRouteRuleResponseBodyList;
+export declare const ListIpLoadbalancingTcpRouteRuleResponse: S.Schema<ListIpLoadbalancingTcpRouteRuleResponse>;
+export interface ListIpLoadbalancingUdpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of vrackNetworkId property (=) */
+    vrackNetworkId?: number;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingUdpFarmRequest: S.Schema<ListIpLoadbalancingUdpFarmRequest>;
+export type ListIpLoadbalancingUdpFarmResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingUdpFarmResponseBodyList: S.Schema<ListIpLoadbalancingUdpFarmResponseBodyList>;
+export type ListIpLoadbalancingUdpFarmResponse = ListIpLoadbalancingUdpFarmResponseBodyList;
+export declare const ListIpLoadbalancingUdpFarmResponse: S.Schema<ListIpLoadbalancingUdpFarmResponse>;
+export interface ListIpLoadbalancingUdpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Filter the value of address property (=) */
+    address?: string;
+    /** Filter the value of status property (=) */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+}
+export declare const ListIpLoadbalancingUdpFarmServerRequest: S.Schema<ListIpLoadbalancingUdpFarmServerRequest>;
+export type ListIpLoadbalancingUdpFarmServerResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingUdpFarmServerResponseBodyList: S.Schema<ListIpLoadbalancingUdpFarmServerResponseBodyList>;
+export type ListIpLoadbalancingUdpFarmServerResponse = ListIpLoadbalancingUdpFarmServerResponseBodyList;
+export declare const ListIpLoadbalancingUdpFarmServerResponse: S.Schema<ListIpLoadbalancingUdpFarmServerResponse>;
+export interface ListIpLoadbalancingUdpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of defaultFarmId property (=) */
+    defaultFarmId?: number;
+    /** Filter the value of port property (like) */
+    port?: string;
+    /** Filter the value of zone property (=) */
+    zone?: string;
+}
+export declare const ListIpLoadbalancingUdpFrontendRequest: S.Schema<ListIpLoadbalancingUdpFrontendRequest>;
+export type ListIpLoadbalancingUdpFrontendResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingUdpFrontendResponseBodyList: S.Schema<ListIpLoadbalancingUdpFrontendResponseBodyList>;
+export type ListIpLoadbalancingUdpFrontendResponse = ListIpLoadbalancingUdpFrontendResponseBodyList;
+export declare const ListIpLoadbalancingUdpFrontendResponse: S.Schema<ListIpLoadbalancingUdpFrontendResponse>;
+export interface ListIpLoadbalancingVrackNetworkRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Filter the value of subnet property (=) */
+    subnet?: string;
+    /** Filter the value of vlan property (=) */
+    vlan?: number;
+}
+export declare const ListIpLoadbalancingVrackNetworkRequest: S.Schema<ListIpLoadbalancingVrackNetworkRequest>;
+export type ListIpLoadbalancingVrackNetworkResponseBodyList = Array<number>;
+export declare const ListIpLoadbalancingVrackNetworkResponseBodyList: S.Schema<ListIpLoadbalancingVrackNetworkResponseBodyList>;
+export type ListIpLoadbalancingVrackNetworkResponse = ListIpLoadbalancingVrackNetworkResponseBodyList;
+export declare const ListIpLoadbalancingVrackNetworkResponse: S.Schema<ListIpLoadbalancingVrackNetworkResponse>;
+export interface ListIpLoadbalancingVrackStatusRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingVrackStatusRequest: S.Schema<ListIpLoadbalancingVrackStatusRequest>;
+/** Possible values for load balancing vRack state */
+export type IpLoadbalancingVrackStateEnum = "activating" | "active" | "deactivating" | "inactive";
+export declare const IpLoadbalancingVrackStateEnum: any;
+/** Ongoing task related to vRack installation or uninstallation on your Load Balancer */
+export type IpLoadbalancingVrackInformationTaskList = Array<number>;
+export declare const IpLoadbalancingVrackInformationTaskList: S.Schema<IpLoadbalancingVrackInformationTaskList>;
+/** Information about vRack for your Load Balancer */
+export interface IpLoadbalancingVrackInformation {
+    /** State of the vRack link to your Load Balancer */
+    state?: IpLoadbalancingVrackStateEnum;
+    /** Ongoing task related to vRack installation or uninstallation on your Load Balancer */
+    task?: IpLoadbalancingVrackInformationTaskList;
+    /** Name of the vRack on which the current Load Balancer is attached to, as it is named on vRack product */
+    vrackName?: string | null;
+}
+export declare const IpLoadbalancingVrackInformation: S.Schema<IpLoadbalancingVrackInformation>;
+export interface ListIpLoadbalancingVrackTransparentGatewaysRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingVrackTransparentGatewaysRequest: S.Schema<ListIpLoadbalancingVrackTransparentGatewaysRequest>;
+/** Aims to help you configure needed transparent interfaces */
+export interface IpLoadbalancingVrackTransparentGateways {
+    /** address */
+    address?: string;
+    /** gateway */
+    gateway?: string;
+    /** vlan */
+    vlan?: number;
+}
+export declare const IpLoadbalancingVrackTransparentGateways: S.Schema<IpLoadbalancingVrackTransparentGateways>;
+export type ListIpLoadbalancingVrackTransparentGatewaysResponseBodyList = Array<IpLoadbalancingVrackTransparentGateways>;
+export declare const ListIpLoadbalancingVrackTransparentGatewaysResponseBodyList: S.Schema<ListIpLoadbalancingVrackTransparentGatewaysResponseBodyList>;
+export type ListIpLoadbalancingVrackTransparentGatewaysResponse = ListIpLoadbalancingVrackTransparentGatewaysResponseBodyList;
+export declare const ListIpLoadbalancingVrackTransparentGatewaysResponse: S.Schema<ListIpLoadbalancingVrackTransparentGatewaysResponse>;
+export interface ListIpLoadbalancingZoneRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const ListIpLoadbalancingZoneRequest: S.Schema<ListIpLoadbalancingZoneRequest>;
+export type ListIpLoadbalancingZoneResponseBodyList = Array<string>;
+export declare const ListIpLoadbalancingZoneResponseBodyList: S.Schema<ListIpLoadbalancingZoneResponseBodyList>;
+export type ListIpLoadbalancingZoneResponse = ListIpLoadbalancingZoneResponseBodyList;
+export declare const ListIpLoadbalancingZoneResponse: S.Schema<ListIpLoadbalancingZoneResponse>;
+export interface PutIpLoadbalancingRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Set the name displayed in ManagerV6 for your iplb (max 50 chars) */
+    displayName?: string | null;
+    /** Modern oldest compatible clients : Firefox 27, Chrome 30, IE 11 on Windows 7, Edge, Opera 17, Safari 9, Android 5.0, and Java 8. Intermediate oldest compatible clients : Firefox 1, Chrome 1, IE 7, Opera 5, Safari 1, Windows XP IE8, Android 2.3, Java 7. Intermediate if null. */
+    sslConfiguration?: IpLoadbalancingSslConfigurationEnum | (string & {}) | null;
+}
+export declare const PutIpLoadbalancingRequest: S.Schema<PutIpLoadbalancingRequest>;
+export interface PutIpLoadbalancingResponse {
+}
+export declare const PutIpLoadbalancingResponse: S.Schema<PutIpLoadbalancingResponse>;
+export interface PutIpLoadbalancingHttpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Load balancing algorithm. 'roundrobin' if null */
+    balance?: IpLoadbalancingBalanceHTTPEnum | (string & {}) | null;
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string | null;
+    /** Port attached to your farm. Inherited from frontend if null */
+    port?: number | null;
+    /** Probe used to determine if a backend is alive and can handle requests. Defaults to tcp on the same port as the farm */
+    probe?: IpLoadbalancingBackendProbe | null;
+    /** Stickiness type. No stickiness if null */
+    stickiness?: IpLoadbalancingStickinessHTTPEnum | (string & {}) | null;
+    /** Internal Load Balancer identifier of the vRack private network attached to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number | null;
+}
+export declare const PutIpLoadbalancingHttpFarmRequest: S.Schema<PutIpLoadbalancingHttpFarmRequest>;
+export interface PutIpLoadbalancingHttpFarmResponse {
+}
+export declare const PutIpLoadbalancingHttpFarmResponse: S.Schema<PutIpLoadbalancingHttpFarmResponse>;
+export interface PutIpLoadbalancingHttpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    /** Backup state. Default: 'false' */
+    backup?: boolean;
+    /** Certificate chain. Allow server certificate verification (Avoid man-in-the-middle attacks) */
+    chain?: string | null;
+    /** Server cookie value configured for cookie stickiness */
+    cookie?: string | null;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string | null;
+    /** Set action when backend marked down. (No action if null) */
+    onMarkedDown?: IpLoadbalancingOnMarkedDownEnum | (string & {}) | null;
+    /** Port attached to your server. Inherited from farm if null */
+    port?: number | null;
+    /** Probe state. Default: 'false' */
+    probe?: boolean;
+    /** Disabled if null. Send PROXY protocol header. Requires a compatible server. */
+    proxyProtocolVersion?: IpLoadbalancingProxyProtocolVersionEnum | (string & {}) | null;
+    /** SSL ciphering. Probes will also be sent ciphered. Default: 'false' */
+    ssl?: boolean;
+    /** Status attached to your server */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+    /** Weight value. Defaults to 1. 0 if not used in load balancing. Servers with higher weight get more requests. */
+    weight?: number | null;
+}
+export declare const PutIpLoadbalancingHttpFarmServerRequest: S.Schema<PutIpLoadbalancingHttpFarmServerRequest>;
+export interface PutIpLoadbalancingHttpFarmServerResponse {
+}
+export declare const PutIpLoadbalancingHttpFarmServerResponse: S.Schema<PutIpLoadbalancingHttpFarmServerResponse>;
+/** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type PutIpLoadbalancingHttpFrontendRequestAllowedSourceList = Array<string>;
+export declare const PutIpLoadbalancingHttpFrontendRequestAllowedSourceList: S.Schema<PutIpLoadbalancingHttpFrontendRequestAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type PutIpLoadbalancingHttpFrontendRequestDedicatedIpfoList = Array<string>;
+export declare const PutIpLoadbalancingHttpFrontendRequestDedicatedIpfoList: S.Schema<PutIpLoadbalancingHttpFrontendRequestDedicatedIpfoList>;
+/** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type PutIpLoadbalancingHttpFrontendRequestDeniedSourceList = Array<string>;
+export declare const PutIpLoadbalancingHttpFrontendRequestDeniedSourceList: S.Schema<PutIpLoadbalancingHttpFrontendRequestDeniedSourceList>;
+/** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+export type PutIpLoadbalancingHttpFrontendRequestHttpHeaderList = Array<string>;
+export declare const PutIpLoadbalancingHttpFrontendRequestHttpHeaderList: S.Schema<PutIpLoadbalancingHttpFrontendRequestHttpHeaderList>;
+export interface PutIpLoadbalancingHttpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+    /** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: PutIpLoadbalancingHttpFrontendRequestAllowedSourceList | null;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: PutIpLoadbalancingHttpFrontendRequestDedicatedIpfoList | null;
+    /** Default HTTP Farm of your frontend */
+    defaultFarmId?: number | null;
+    /** Default ssl served to your customer */
+    defaultSslId?: number | null;
+    /** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: PutIpLoadbalancingHttpFrontendRequestDeniedSourceList | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string | null;
+    /** HTTP Strict Transport Security. Default: 'false' */
+    hsts?: boolean;
+    /** Add header to your frontend. Useful variables admitted : %ci <=> client_ip, %cp <=> client_port */
+    httpHeader?: PutIpLoadbalancingHttpFrontendRequestHttpHeaderList | null;
+    /** Listening port(s) on the server */
+    port?: string;
+    /** HTTP redirection (Ex : http://www.ovh.com) */
+    redirectLocation?: string | null;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const PutIpLoadbalancingHttpFrontendRequest: S.Schema<PutIpLoadbalancingHttpFrontendRequest>;
+export interface PutIpLoadbalancingHttpFrontendResponse {
+}
+export declare const PutIpLoadbalancingHttpFrontendResponse: S.Schema<PutIpLoadbalancingHttpFrontendResponse>;
+export interface PutIpLoadbalancingHttpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Action triggered when all rules match */
+    action?: IpLoadbalancingRouteHttpAction;
+    /** Human readable name for your route, this field is for you */
+    displayName?: string | null;
+    /** Route traffic for this frontend */
+    frontendId?: number | null;
+    /** Route priority ([0..255]). 0 if null. Highest priority routes are evaluated last. Only the first matching route will trigger an action */
+    weight?: number;
+}
+export declare const PutIpLoadbalancingHttpRouteRequest: S.Schema<PutIpLoadbalancingHttpRouteRequest>;
+export interface PutIpLoadbalancingHttpRouteResponse {
+}
+export declare const PutIpLoadbalancingHttpRouteResponse: S.Schema<PutIpLoadbalancingHttpRouteResponse>;
+export interface PutIpLoadbalancingHttpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Id of your rule */
+    ruleId: number;
+    /** Human readable name for your rule */
+    displayName?: string | null;
+    /** Name of the field to match like "protocol" or "host". See "/ipLoadbalancing/{serviceName}/availableRouteRules" for a list of available rules */
+    field?: string;
+    /** Matching operator. Not all operators are available for all fields. See "/ipLoadbalancing/{serviceName}/availableRouteRules" */
+    match?: IpLoadbalancingRouteRuleMatchesEnum | (string & {});
+    /** Invert the matching operator effect */
+    negate?: boolean;
+    /** Value to match against this match. Interpretation if this field depends on the match and field */
+    pattern?: string | null;
+    /** Name of sub-field, if applicable. This may be a Cookie or Header name for instance */
+    subField?: string | null;
+}
+export declare const PutIpLoadbalancingHttpRouteRuleRequest: S.Schema<PutIpLoadbalancingHttpRouteRuleRequest>;
+export interface PutIpLoadbalancingHttpRouteRuleResponse {
+}
+export declare const PutIpLoadbalancingHttpRouteRuleResponse: S.Schema<PutIpLoadbalancingHttpRouteRuleResponse>;
+export interface PutIpLoadbalancingQuotaRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Zone of your quota */
+    zone: string;
+    /** Quota alert value in bytes. When reached, we will send you an alert. Default : included quota with your offer */
+    alert?: number | null;
+}
+export declare const PutIpLoadbalancingQuotaRequest: S.Schema<PutIpLoadbalancingQuotaRequest>;
+export interface PutIpLoadbalancingQuotaResponse {
+}
+export declare const PutIpLoadbalancingQuotaResponse: S.Schema<PutIpLoadbalancingQuotaResponse>;
+export interface PutIpLoadbalancingServiceInfosRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutIpLoadbalancingServiceInfosRequest: S.Schema<PutIpLoadbalancingServiceInfosRequest>;
+export interface PutIpLoadbalancingServiceInfosResponse {
+}
+export declare const PutIpLoadbalancingServiceInfosResponse: S.Schema<PutIpLoadbalancingServiceInfosResponse>;
+export interface PutIpLoadbalancingSslRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your SSL certificate */
+    id: number;
+    /** Human readable name for your ssl certificate, this field is for you */
+    displayName?: string | null;
+}
+export declare const PutIpLoadbalancingSslRequest: S.Schema<PutIpLoadbalancingSslRequest>;
+export interface PutIpLoadbalancingSslResponse {
+}
+export declare const PutIpLoadbalancingSslResponse: S.Schema<PutIpLoadbalancingSslResponse>;
+export interface PutIpLoadbalancingTcpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Load balancing algorithm. 'roundrobin' if null */
+    balance?: IpLoadbalancingBalanceTCPEnum | (string & {}) | null;
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string | null;
+    /** Port attached to your farm. Inherited from frontend if null */
+    port?: number | null;
+    /** Probe used to determine if a backend is alive and can handle requests. Defaults to tcp on the same port as the farm */
+    probe?: IpLoadbalancingBackendProbe | null;
+    /** Stickiness type. No stickiness if null */
+    stickiness?: IpLoadbalancingStickinessTCPEnum | (string & {}) | null;
+    /** Internal Load Balancer identifier of the vRack private network attached to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number | null;
+}
+export declare const PutIpLoadbalancingTcpFarmRequest: S.Schema<PutIpLoadbalancingTcpFarmRequest>;
+export interface PutIpLoadbalancingTcpFarmResponse {
+}
+export declare const PutIpLoadbalancingTcpFarmResponse: S.Schema<PutIpLoadbalancingTcpFarmResponse>;
+export interface PutIpLoadbalancingTcpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    /** Backup state. Default: 'false' */
+    backup?: boolean;
+    /** Certificate chain. Allow server certificate verification (Avoid man-in-the-middle attacks) */
+    chain?: string | null;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string | null;
+    /** Set action when backend marked down. (No action if null) */
+    onMarkedDown?: IpLoadbalancingOnMarkedDownEnum | (string & {}) | null;
+    /** Port attached to your server. Inherited from farm if null */
+    port?: number | null;
+    /** Probe state. Default: 'false' */
+    probe?: boolean;
+    /** Disabled if null. Send PROXY protocol header. Requires a compatible server. */
+    proxyProtocolVersion?: IpLoadbalancingProxyProtocolVersionEnum | (string & {}) | null;
+    /** SSL ciphering. Probes will also be sent ciphered */
+    ssl?: boolean;
+    /** Status attached to your server */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+    /** Weight value. Defaults to 1. 0 if not used in load balancing. Servers with higher weight get more requests. */
+    weight?: number | null;
+}
+export declare const PutIpLoadbalancingTcpFarmServerRequest: S.Schema<PutIpLoadbalancingTcpFarmServerRequest>;
+export interface PutIpLoadbalancingTcpFarmServerResponse {
+}
+export declare const PutIpLoadbalancingTcpFarmServerResponse: S.Schema<PutIpLoadbalancingTcpFarmServerResponse>;
+/** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type PutIpLoadbalancingTcpFrontendRequestAllowedSourceList = Array<string>;
+export declare const PutIpLoadbalancingTcpFrontendRequestAllowedSourceList: S.Schema<PutIpLoadbalancingTcpFrontendRequestAllowedSourceList>;
+/** Only attach frontend on these ip. No restriction if null */
+export type PutIpLoadbalancingTcpFrontendRequestDedicatedIpfoList = Array<string>;
+export declare const PutIpLoadbalancingTcpFrontendRequestDedicatedIpfoList: S.Schema<PutIpLoadbalancingTcpFrontendRequestDedicatedIpfoList>;
+/** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+export type PutIpLoadbalancingTcpFrontendRequestDeniedSourceList = Array<string>;
+export declare const PutIpLoadbalancingTcpFrontendRequestDeniedSourceList: S.Schema<PutIpLoadbalancingTcpFrontendRequestDeniedSourceList>;
+export interface PutIpLoadbalancingTcpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+    /** Restrict IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    allowedSource?: PutIpLoadbalancingTcpFrontendRequestAllowedSourceList | null;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: PutIpLoadbalancingTcpFrontendRequestDedicatedIpfoList | null;
+    /** Default TCP Farm of your frontend */
+    defaultFarmId?: number | null;
+    /** Default ssl served to your customer */
+    defaultSslId?: number | null;
+    /** Deny IP Load Balancing access to these ip block. No restriction if null. You cannot specify allowedSource and deniedSource both at the same time */
+    deniedSource?: PutIpLoadbalancingTcpFrontendRequestDeniedSourceList | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string | null;
+    /** Listening port(s) on the server */
+    port?: string;
+    /** SSL deciphering. Default: 'false' */
+    ssl?: boolean;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const PutIpLoadbalancingTcpFrontendRequest: S.Schema<PutIpLoadbalancingTcpFrontendRequest>;
+export interface PutIpLoadbalancingTcpFrontendResponse {
+}
+export declare const PutIpLoadbalancingTcpFrontendResponse: S.Schema<PutIpLoadbalancingTcpFrontendResponse>;
+export interface PutIpLoadbalancingTcpRouteRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Action triggered when all rules match */
+    action?: IpLoadbalancingRouteTcpAction;
+    /** Human readable name for your route, this field is for you */
+    displayName?: string | null;
+    /** Route traffic for this frontend */
+    frontendId?: number | null;
+    /** Route priority ([0..255]). 0 if null. Highest priority routes are evaluated last. Only the first matching route will trigger an action */
+    weight?: number;
+}
+export declare const PutIpLoadbalancingTcpRouteRequest: S.Schema<PutIpLoadbalancingTcpRouteRequest>;
+export interface PutIpLoadbalancingTcpRouteResponse {
+}
+export declare const PutIpLoadbalancingTcpRouteResponse: S.Schema<PutIpLoadbalancingTcpRouteResponse>;
+export interface PutIpLoadbalancingTcpRouteRuleRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your route */
+    routeId: number;
+    /** Id of your rule */
+    ruleId: number;
+    /** Human readable name for your rule */
+    displayName?: string | null;
+    /** Name of the field to match like "protocol" or "host". See "/ipLoadbalancing/{serviceName}/availableRouteRules" for a list of available rules */
+    field?: string;
+    /** Matching operator. Not all operators are available for all fields. See "/ipLoadbalancing/{serviceName}/availableRouteRules" */
+    match?: IpLoadbalancingRouteRuleMatchesEnum | (string & {});
+    /** Invert the matching operator effect */
+    negate?: boolean;
+    /** Value to match against this match. Interpretation if this field depends on the match and field */
+    pattern?: string | null;
+    /** Name of sub-field, if applicable. This may be a Cookie or Header name for instance */
+    subField?: string | null;
+}
+export declare const PutIpLoadbalancingTcpRouteRuleRequest: S.Schema<PutIpLoadbalancingTcpRouteRuleRequest>;
+export interface PutIpLoadbalancingTcpRouteRuleResponse {
+}
+export declare const PutIpLoadbalancingTcpRouteRuleResponse: S.Schema<PutIpLoadbalancingTcpRouteRuleResponse>;
+export interface PutIpLoadbalancingUdpFarmRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Human readable name for your backend, this field is for you */
+    displayName?: string | null;
+    /** Port attached to your farm. Inherited from frontend if null */
+    port?: number;
+    /** Internal Load Balancer identifier of the vRack private network attached to your farm, mandatory when your Load Balancer is attached to a vRack */
+    vrackNetworkId?: number | null;
+}
+export declare const PutIpLoadbalancingUdpFarmRequest: S.Schema<PutIpLoadbalancingUdpFarmRequest>;
+export interface PutIpLoadbalancingUdpFarmResponse {
+}
+export declare const PutIpLoadbalancingUdpFarmResponse: S.Schema<PutIpLoadbalancingUdpFarmResponse>;
+export interface PutIpLoadbalancingUdpFarmServerRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your farm */
+    farmId: number;
+    /** Id of your server */
+    serverId: number;
+    /** Human readable name for your server, this field is for you */
+    displayName?: string | null;
+    /** Port attached to your server. Inherited from farm if null */
+    port?: number | null;
+    /** Status attached to your server */
+    status?: IpLoadbalancingBackendCustomerServerStatusEnum | (string & {});
+}
+export declare const PutIpLoadbalancingUdpFarmServerRequest: S.Schema<PutIpLoadbalancingUdpFarmServerRequest>;
+export interface PutIpLoadbalancingUdpFarmServerResponse {
+}
+export declare const PutIpLoadbalancingUdpFarmServerResponse: S.Schema<PutIpLoadbalancingUdpFarmServerResponse>;
+/** Only attach frontend on these ip. No restriction if null */
+export type PutIpLoadbalancingUdpFrontendRequestDedicatedIpfoList = Array<string>;
+export declare const PutIpLoadbalancingUdpFrontendRequestDedicatedIpfoList: S.Schema<PutIpLoadbalancingUdpFrontendRequestDedicatedIpfoList>;
+export interface PutIpLoadbalancingUdpFrontendRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Id of your frontend */
+    frontendId: number;
+    /** Only attach frontend on these ip. No restriction if null */
+    dedicatedIpfo?: PutIpLoadbalancingUdpFrontendRequestDedicatedIpfoList | null;
+    /** Default UDP Farm of your frontend */
+    defaultFarmId?: number | null;
+    /** Disable frontend. Default: 'false' */
+    disabled?: boolean;
+    /** Human readable name for your frontend, this field is for you */
+    displayName?: string | null;
+    /** Listening port(s) on the server */
+    port?: string;
+    /** Zone of you frontend */
+    zone?: string;
+}
+export declare const PutIpLoadbalancingUdpFrontendRequest: S.Schema<PutIpLoadbalancingUdpFrontendRequest>;
+export interface PutIpLoadbalancingUdpFrontendResponse {
+}
+export declare const PutIpLoadbalancingUdpFrontendResponse: S.Schema<PutIpLoadbalancingUdpFrontendResponse>;
+export interface PutIpLoadbalancingVrackNetworkRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Internal Load Balancer identifier of the vRack private network description */
+    vrackNetworkId: number;
+    /** Human readable name for your vrack network */
+    displayName?: string | null;
+    /** An IP block used as a pool of IPs by this Load Balancer to connect to the servers in this private network. The block must be in the private network and reserved for the Load Balancer */
+    natIp?: string;
+    /** VLAN of the private network in the vRack. 0 if the private network is not in a VLAN */
+    vlan?: number;
+}
+export declare const PutIpLoadbalancingVrackNetworkRequest: S.Schema<PutIpLoadbalancingVrackNetworkRequest>;
+export interface PutIpLoadbalancingVrackNetworkResponse {
+}
+export declare const PutIpLoadbalancingVrackNetworkResponse: S.Schema<PutIpLoadbalancingVrackNetworkResponse>;
+export interface RefreshIpLoadbalancingRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** The zone(s) of your iplb */
+    zone?: string;
+}
+export declare const RefreshIpLoadbalancingRequest: S.Schema<RefreshIpLoadbalancingRequest>;
+export interface TerminateIpLoadbalancingRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+}
+export declare const TerminateIpLoadbalancingRequest: S.Schema<TerminateIpLoadbalancingRequest>;
+export type TerminateIpLoadbalancingResponse = string;
+export declare const TerminateIpLoadbalancingResponse: S.Schema<TerminateIpLoadbalancingResponse>;
+export interface TerminateIpLoadbalancingZoneRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Name of your zone */
+    name: string;
+}
+export declare const TerminateIpLoadbalancingZoneRequest: S.Schema<TerminateIpLoadbalancingZoneRequest>;
+export interface TerminateIpLoadbalancingZoneResponse {
+}
+export declare const TerminateIpLoadbalancingZoneResponse: S.Schema<TerminateIpLoadbalancingZoneResponse>;
+/** Farm Id you want to attach to that vrack network */
+export type UpdateIpLoadbalancingVrackNetworkFarmIdRequestFarmIdList = Array<number>;
+export declare const UpdateIpLoadbalancingVrackNetworkFarmIdRequestFarmIdList: S.Schema<UpdateIpLoadbalancingVrackNetworkFarmIdRequestFarmIdList>;
+export interface UpdateIpLoadbalancingVrackNetworkFarmIdRequest {
+    /** The internal name of your IP load balancing */
+    serviceName: string;
+    /** Internal Load Balancer identifier of the vRack private network description */
+    vrackNetworkId: number;
+    /** Farm Id you want to attach to that vrack network */
+    farmId: UpdateIpLoadbalancingVrackNetworkFarmIdRequestFarmIdList;
+}
+export declare const UpdateIpLoadbalancingVrackNetworkFarmIdRequest: S.Schema<UpdateIpLoadbalancingVrackNetworkFarmIdRequest>;
+export type CancelIpLoadbalancingZoneTerminationError = OvhOpError;
+/** Cancel the termination request of your service zone option */
+export declare const cancelIpLoadbalancingZoneTermination: API.OperationMethod<CancelIpLoadbalancingZoneTerminationRequest, CancelIpLoadbalancingZoneTerminationResponse, CancelIpLoadbalancingZoneTerminationError, OvhOpContext>;
+export type ConfirmIpLoadbalancingTerminationError = OvhOpError;
+/** Confirm service termination */
+export declare const confirmIpLoadbalancingTermination: API.OperationMethod<ConfirmIpLoadbalancingTerminationRequest, ConfirmIpLoadbalancingTerminationResponse, ConfirmIpLoadbalancingTerminationError, OvhOpContext>;
+export type CreateIpLoadbalancingChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createIpLoadbalancingChangeContact: API.OperationMethod<CreateIpLoadbalancingChangeContactRequest, CreateIpLoadbalancingChangeContactResponse, CreateIpLoadbalancingChangeContactError, OvhOpContext>;
+export type CreateIpLoadbalancingFreeCertificateError = OvhOpError;
+/** Order a free certificate. We order and deliver it for you */
+export declare const createIpLoadbalancingFreeCertificate: API.OperationMethod<CreateIpLoadbalancingFreeCertificateRequest, IpLoadbalancingTaskTask, CreateIpLoadbalancingFreeCertificateError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpFarmError = OvhOpError;
+/** Add a new HTTP Farm on your IP Load Balancing */
+export declare const createIpLoadbalancingHttpFarm: API.OperationMethod<CreateIpLoadbalancingHttpFarmRequest, IpLoadbalancingBackendHttpBackendHttp, CreateIpLoadbalancingHttpFarmError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpFarmServerError = OvhOpError;
+/** Add a server to an HTTP Farm */
+export declare const createIpLoadbalancingHttpFarmServer: API.OperationMethod<CreateIpLoadbalancingHttpFarmServerRequest, IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer, CreateIpLoadbalancingHttpFarmServerError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpFarmServerTransparentError = OvhOpError;
+/** Add a new vrack transparent ip */
+export declare const createIpLoadbalancingHttpFarmServerTransparent: API.OperationMethod<CreateIpLoadbalancingHttpFarmServerTransparentRequest, IpLoadbalancingVrackTransparentIpVrackTransparentIp, CreateIpLoadbalancingHttpFarmServerTransparentError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpFrontendError = OvhOpError;
+/** Add a new http frontend on your IP Load Balancing */
+export declare const createIpLoadbalancingHttpFrontend: API.OperationMethod<CreateIpLoadbalancingHttpFrontendRequest, IpLoadbalancingFrontendHttpFrontendHttp, CreateIpLoadbalancingHttpFrontendError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpFrontendPrivateError = OvhOpError;
+/** Move the frontend in or out vrack */
+export declare const createIpLoadbalancingHttpFrontendPrivate: API.OperationMethod<CreateIpLoadbalancingHttpFrontendPrivateRequest, IpLoadbalancingFrontendFrontend, CreateIpLoadbalancingHttpFrontendPrivateError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpRouteError = OvhOpError;
+/** Add a new HTTP route to your frontend */
+export declare const createIpLoadbalancingHttpRoute: API.OperationMethod<CreateIpLoadbalancingHttpRouteRequest, IpLoadbalancingRouteHttpRouteHttp, CreateIpLoadbalancingHttpRouteError, OvhOpContext>;
+export type CreateIpLoadbalancingHttpRouteRuleError = OvhOpError;
+/** Add a new rule to your route */
+export declare const createIpLoadbalancingHttpRouteRule: API.OperationMethod<CreateIpLoadbalancingHttpRouteRuleRequest, IpLoadbalancingRouteRuleRouteRule, CreateIpLoadbalancingHttpRouteRuleError, OvhOpContext>;
+export type CreateIpLoadbalancingLogSubscriptionError = OvhOpError;
+/** Create a log subscription for your Load Balancer */
+export declare const createIpLoadbalancingLogSubscription: API.OperationMethod<CreateIpLoadbalancingLogSubscriptionRequest, IpLoadbalancingLogSubscriptionResponse, CreateIpLoadbalancingLogSubscriptionError, OvhOpContext>;
+export type CreateIpLoadbalancingLogUrlError = OvhOpError;
+/** Generate a log url */
+export declare const createIpLoadbalancingLogUrl: API.OperationMethod<CreateIpLoadbalancingLogUrlRequest, IpLoadbalancingLogUrl, CreateIpLoadbalancingLogUrlError, OvhOpContext>;
+export type CreateIpLoadbalancingSslError = OvhOpError;
+/** Add a new custom SSL certificate on your IP Load Balancing */
+export declare const createIpLoadbalancingSsl: API.OperationMethod<CreateIpLoadbalancingSslRequest, IpLoadbalancingSslSsl, CreateIpLoadbalancingSslError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpFarmError = OvhOpError;
+/** Add a new TCP Farm on your IP Load Balancing */
+export declare const createIpLoadbalancingTcpFarm: API.OperationMethod<CreateIpLoadbalancingTcpFarmRequest, IpLoadbalancingBackendTcpBackendTcp, CreateIpLoadbalancingTcpFarmError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpFarmServerError = OvhOpError;
+/** Add a server to a TCP Farm */
+export declare const createIpLoadbalancingTcpFarmServer: API.OperationMethod<CreateIpLoadbalancingTcpFarmServerRequest, IpLoadbalancingBackendTcpCustomerServerBackendTCPServer, CreateIpLoadbalancingTcpFarmServerError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpFarmServerTransparentError = OvhOpError;
+/** Add a new vrack transparent ip */
+export declare const createIpLoadbalancingTcpFarmServerTransparent: API.OperationMethod<CreateIpLoadbalancingTcpFarmServerTransparentRequest, IpLoadbalancingVrackTransparentIpVrackTransparentIp, CreateIpLoadbalancingTcpFarmServerTransparentError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpFrontendError = OvhOpError;
+/** Add a new TCP frontend on your IP Load Balancing */
+export declare const createIpLoadbalancingTcpFrontend: API.OperationMethod<CreateIpLoadbalancingTcpFrontendRequest, IpLoadbalancingFrontendTcpFrontendTcp, CreateIpLoadbalancingTcpFrontendError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpFrontendPrivateError = OvhOpError;
+/** Move the frontend in or out vrack */
+export declare const createIpLoadbalancingTcpFrontendPrivate: API.OperationMethod<CreateIpLoadbalancingTcpFrontendPrivateRequest, IpLoadbalancingFrontendFrontend, CreateIpLoadbalancingTcpFrontendPrivateError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpRouteError = OvhOpError;
+/** Add a new TCP route to your frontend */
+export declare const createIpLoadbalancingTcpRoute: API.OperationMethod<CreateIpLoadbalancingTcpRouteRequest, IpLoadbalancingRouteTcpRouteTcp, CreateIpLoadbalancingTcpRouteError, OvhOpContext>;
+export type CreateIpLoadbalancingTcpRouteRuleError = OvhOpError;
+/** Add a new rule to your route */
+export declare const createIpLoadbalancingTcpRouteRule: API.OperationMethod<CreateIpLoadbalancingTcpRouteRuleRequest, IpLoadbalancingRouteRuleRouteRule, CreateIpLoadbalancingTcpRouteRuleError, OvhOpContext>;
+export type CreateIpLoadbalancingUdpFarmError = OvhOpError;
+/** Add a new UDP Farm on your IP Load Balancing */
+export declare const createIpLoadbalancingUdpFarm: API.OperationMethod<CreateIpLoadbalancingUdpFarmRequest, IpLoadbalancingBackendUdpBackendUdp, CreateIpLoadbalancingUdpFarmError, OvhOpContext>;
+export type CreateIpLoadbalancingUdpFarmServerError = OvhOpError;
+/** Add a server to an UDP Farm */
+export declare const createIpLoadbalancingUdpFarmServer: API.OperationMethod<CreateIpLoadbalancingUdpFarmServerRequest, IpLoadbalancingBackendUdpCustomerServerBackendUDPServer, CreateIpLoadbalancingUdpFarmServerError, OvhOpContext>;
+export type CreateIpLoadbalancingUdpFrontendError = OvhOpError;
+/** Add a new UDP frontend on your IP Load Balancing */
+export declare const createIpLoadbalancingUdpFrontend: API.OperationMethod<CreateIpLoadbalancingUdpFrontendRequest, IpLoadbalancingFrontendUdpFrontendUdp, CreateIpLoadbalancingUdpFrontendError, OvhOpContext>;
+export type CreateIpLoadbalancingVrackNetworkError = OvhOpError;
+/** Add a description of a private network in the attached vRack */
+export declare const createIpLoadbalancingVrackNetwork: API.OperationMethod<CreateIpLoadbalancingVrackNetworkRequest, IpLoadbalancingVrackNetworkVrackNetwork, CreateIpLoadbalancingVrackNetworkError, OvhOpContext>;
+export type DeleteIpLoadbalancingHttpFarmError = OvhOpError;
+/** Delete an HTTP Farm */
+export declare const deleteIpLoadbalancingHttpFarm: API.OperationMethod<DeleteIpLoadbalancingHttpFarmRequest, DeleteIpLoadbalancingHttpFarmResponse, DeleteIpLoadbalancingHttpFarmError, OvhOpContext>;
+export type DeleteIpLoadbalancingHttpFarmServerError = OvhOpError;
+/** Delete a server from an HTTP Farm */
+export declare const deleteIpLoadbalancingHttpFarmServer: API.OperationMethod<DeleteIpLoadbalancingHttpFarmServerRequest, DeleteIpLoadbalancingHttpFarmServerResponse, DeleteIpLoadbalancingHttpFarmServerError, OvhOpContext>;
+export type DeleteIpLoadbalancingHttpFarmServerTransparentError = OvhOpError;
+/** Delete a vrack transparent ip */
+export declare const deleteIpLoadbalancingHttpFarmServerTransparent: API.OperationMethod<DeleteIpLoadbalancingHttpFarmServerTransparentRequest, DeleteIpLoadbalancingHttpFarmServerTransparentResponse, DeleteIpLoadbalancingHttpFarmServerTransparentError, OvhOpContext>;
+export type DeleteIpLoadbalancingHttpFrontendError = OvhOpError;
+/** Delete an HTTP frontend */
+export declare const deleteIpLoadbalancingHttpFrontend: API.OperationMethod<DeleteIpLoadbalancingHttpFrontendRequest, DeleteIpLoadbalancingHttpFrontendResponse, DeleteIpLoadbalancingHttpFrontendError, OvhOpContext>;
+export type DeleteIpLoadbalancingHttpRouteError = OvhOpError;
+/** Delete this HTTP route */
+export declare const deleteIpLoadbalancingHttpRoute: API.OperationMethod<DeleteIpLoadbalancingHttpRouteRequest, DeleteIpLoadbalancingHttpRouteResponse, DeleteIpLoadbalancingHttpRouteError, OvhOpContext>;
+export type DeleteIpLoadbalancingHttpRouteRuleError = OvhOpError;
+/** Delete this rule from the route */
+export declare const deleteIpLoadbalancingHttpRouteRule: API.OperationMethod<DeleteIpLoadbalancingHttpRouteRuleRequest, DeleteIpLoadbalancingHttpRouteRuleResponse, DeleteIpLoadbalancingHttpRouteRuleError, OvhOpContext>;
+export type DeleteIpLoadbalancingLogSubscriptionError = OvhOpError;
+/** Delete a log subscription for your Load Balancer */
+export declare const deleteIpLoadbalancingLogSubscription: API.OperationMethod<DeleteIpLoadbalancingLogSubscriptionRequest, IpLoadbalancingLogSubscriptionResponse, DeleteIpLoadbalancingLogSubscriptionError, OvhOpContext>;
+export type DeleteIpLoadbalancingSslError = OvhOpError;
+/** Delete a custom SSL certificate */
+export declare const deleteIpLoadbalancingSsl: API.OperationMethod<DeleteIpLoadbalancingSslRequest, DeleteIpLoadbalancingSslResponse, DeleteIpLoadbalancingSslError, OvhOpContext>;
+export type DeleteIpLoadbalancingTcpFarmError = OvhOpError;
+/** Delete a TCP Farm */
+export declare const deleteIpLoadbalancingTcpFarm: API.OperationMethod<DeleteIpLoadbalancingTcpFarmRequest, DeleteIpLoadbalancingTcpFarmResponse, DeleteIpLoadbalancingTcpFarmError, OvhOpContext>;
+export type DeleteIpLoadbalancingTcpFarmServerError = OvhOpError;
+/** Delete a server from a TCP Farm */
+export declare const deleteIpLoadbalancingTcpFarmServer: API.OperationMethod<DeleteIpLoadbalancingTcpFarmServerRequest, DeleteIpLoadbalancingTcpFarmServerResponse, DeleteIpLoadbalancingTcpFarmServerError, OvhOpContext>;
+export type DeleteIpLoadbalancingTcpFarmServerTransparentError = OvhOpError;
+/** Delete a vrack transparent ip */
+export declare const deleteIpLoadbalancingTcpFarmServerTransparent: API.OperationMethod<DeleteIpLoadbalancingTcpFarmServerTransparentRequest, DeleteIpLoadbalancingTcpFarmServerTransparentResponse, DeleteIpLoadbalancingTcpFarmServerTransparentError, OvhOpContext>;
+export type DeleteIpLoadbalancingTcpFrontendError = OvhOpError;
+/** Delete an TCP frontend */
+export declare const deleteIpLoadbalancingTcpFrontend: API.OperationMethod<DeleteIpLoadbalancingTcpFrontendRequest, DeleteIpLoadbalancingTcpFrontendResponse, DeleteIpLoadbalancingTcpFrontendError, OvhOpContext>;
+export type DeleteIpLoadbalancingTcpRouteError = OvhOpError;
+/** Delete this TCP route */
+export declare const deleteIpLoadbalancingTcpRoute: API.OperationMethod<DeleteIpLoadbalancingTcpRouteRequest, DeleteIpLoadbalancingTcpRouteResponse, DeleteIpLoadbalancingTcpRouteError, OvhOpContext>;
+export type DeleteIpLoadbalancingTcpRouteRuleError = OvhOpError;
+/** Delete this rule from the route */
+export declare const deleteIpLoadbalancingTcpRouteRule: API.OperationMethod<DeleteIpLoadbalancingTcpRouteRuleRequest, DeleteIpLoadbalancingTcpRouteRuleResponse, DeleteIpLoadbalancingTcpRouteRuleError, OvhOpContext>;
+export type DeleteIpLoadbalancingUdpFarmError = OvhOpError;
+/** Delete an UDP Farm */
+export declare const deleteIpLoadbalancingUdpFarm: API.OperationMethod<DeleteIpLoadbalancingUdpFarmRequest, DeleteIpLoadbalancingUdpFarmResponse, DeleteIpLoadbalancingUdpFarmError, OvhOpContext>;
+export type DeleteIpLoadbalancingUdpFarmServerError = OvhOpError;
+/** Delete a server from an UDP Farm */
+export declare const deleteIpLoadbalancingUdpFarmServer: API.OperationMethod<DeleteIpLoadbalancingUdpFarmServerRequest, DeleteIpLoadbalancingUdpFarmServerResponse, DeleteIpLoadbalancingUdpFarmServerError, OvhOpContext>;
+export type DeleteIpLoadbalancingUdpFrontendError = OvhOpError;
+/** Delete an UDP frontend */
+export declare const deleteIpLoadbalancingUdpFrontend: API.OperationMethod<DeleteIpLoadbalancingUdpFrontendRequest, DeleteIpLoadbalancingUdpFrontendResponse, DeleteIpLoadbalancingUdpFrontendError, OvhOpContext>;
+export type DeleteIpLoadbalancingVrackNetworkError = OvhOpError;
+/** Delete this description of a private network in the vRack. It must not be used by any farm server */
+export declare const deleteIpLoadbalancingVrackNetwork: API.OperationMethod<DeleteIpLoadbalancingVrackNetworkRequest, DeleteIpLoadbalancingVrackNetworkResponse, DeleteIpLoadbalancingVrackNetworkError, OvhOpContext>;
+export type GetIpLoadbalancingError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancing: API.OperationMethod<GetIpLoadbalancingRequest, IpLoadbalancingIpWithIAM, GetIpLoadbalancingError, OvhOpContext>;
+export type GetIpLoadbalancingHttpFarmError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingHttpFarm: API.OperationMethod<GetIpLoadbalancingHttpFarmRequest, IpLoadbalancingBackendHttpBackendHttp, GetIpLoadbalancingHttpFarmError, OvhOpContext>;
+export type GetIpLoadbalancingHttpFarmServerError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingHttpFarmServer: API.OperationMethod<GetIpLoadbalancingHttpFarmServerRequest, IpLoadbalancingBackendHttpCustomerServerBackendHTTPServer, GetIpLoadbalancingHttpFarmServerError, OvhOpContext>;
+export type GetIpLoadbalancingHttpFarmServerTransparentError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingHttpFarmServerTransparent: API.OperationMethod<GetIpLoadbalancingHttpFarmServerTransparentRequest, IpLoadbalancingVrackTransparentIpVrackTransparentIp, GetIpLoadbalancingHttpFarmServerTransparentError, OvhOpContext>;
+export type GetIpLoadbalancingHttpFrontendError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingHttpFrontend: API.OperationMethod<GetIpLoadbalancingHttpFrontendRequest, IpLoadbalancingFrontendHttpFrontendHttp, GetIpLoadbalancingHttpFrontendError, OvhOpContext>;
+export type GetIpLoadbalancingHttpRouteError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingHttpRoute: API.OperationMethod<GetIpLoadbalancingHttpRouteRequest, IpLoadbalancingRouteHttpRouteHttp, GetIpLoadbalancingHttpRouteError, OvhOpContext>;
+export type GetIpLoadbalancingHttpRouteRuleError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingHttpRouteRule: API.OperationMethod<GetIpLoadbalancingHttpRouteRuleRequest, IpLoadbalancingRouteRuleRouteRule, GetIpLoadbalancingHttpRouteRuleError, OvhOpContext>;
+export type GetIpLoadbalancingLogKindError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingLogKind: API.OperationMethod<GetIpLoadbalancingLogKindRequest, IpLoadbalancingLdpKindLdpKind, GetIpLoadbalancingLogKindError, OvhOpContext>;
+export type GetIpLoadbalancingLogSubscriptionError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingLogSubscription: API.OperationMethod<GetIpLoadbalancingLogSubscriptionRequest, IpLoadbalancingLdpSubscriptionLdpSubscription, GetIpLoadbalancingLogSubscriptionError, OvhOpContext>;
+export type GetIpLoadbalancingMetricsTokenError = OvhOpError;
+/** Retrieve metrics token and endpoint for your Load Balancer */
+export declare const getIpLoadbalancingMetricsToken: API.OperationMethod<GetIpLoadbalancingMetricsTokenRequest, IpLoadbalancingMetricsToken, GetIpLoadbalancingMetricsTokenError, OvhOpContext>;
+export type GetIpLoadbalancingQuotaError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingQuota: API.OperationMethod<GetIpLoadbalancingQuotaRequest, IpLoadbalancingQuotaQuota, GetIpLoadbalancingQuotaError, OvhOpContext>;
+export type GetIpLoadbalancingQuotaHistoryError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingQuotaHistory: API.OperationMethod<GetIpLoadbalancingQuotaHistoryRequest, IpLoadbalancingQuotaHistoryQuotaHistory, GetIpLoadbalancingQuotaHistoryError, OvhOpContext>;
+export type GetIpLoadbalancingServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getIpLoadbalancingServiceInfos: API.OperationMethod<GetIpLoadbalancingServiceInfosRequest, ServicesService, GetIpLoadbalancingServiceInfosError, OvhOpContext>;
+export type GetIpLoadbalancingSslError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingSsl: API.OperationMethod<GetIpLoadbalancingSslRequest, IpLoadbalancingSslSsl, GetIpLoadbalancingSslError, OvhOpContext>;
+export type GetIpLoadbalancingStatusError = OvhOpError;
+/** Get the global status of your IPLB */
+export declare const getIpLoadbalancingStatus: API.OperationMethod<GetIpLoadbalancingStatusRequest, IpLoadbalancingStatus, GetIpLoadbalancingStatusError, OvhOpContext>;
+export type GetIpLoadbalancingTaskError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTask: API.OperationMethod<GetIpLoadbalancingTaskRequest, IpLoadbalancingTaskTask, GetIpLoadbalancingTaskError, OvhOpContext>;
+export type GetIpLoadbalancingTcpFarmError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTcpFarm: API.OperationMethod<GetIpLoadbalancingTcpFarmRequest, IpLoadbalancingBackendTcpBackendTcp, GetIpLoadbalancingTcpFarmError, OvhOpContext>;
+export type GetIpLoadbalancingTcpFarmServerError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTcpFarmServer: API.OperationMethod<GetIpLoadbalancingTcpFarmServerRequest, IpLoadbalancingBackendTcpCustomerServerBackendTCPServer, GetIpLoadbalancingTcpFarmServerError, OvhOpContext>;
+export type GetIpLoadbalancingTcpFarmServerTransparentError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTcpFarmServerTransparent: API.OperationMethod<GetIpLoadbalancingTcpFarmServerTransparentRequest, IpLoadbalancingVrackTransparentIpVrackTransparentIp, GetIpLoadbalancingTcpFarmServerTransparentError, OvhOpContext>;
+export type GetIpLoadbalancingTcpFrontendError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTcpFrontend: API.OperationMethod<GetIpLoadbalancingTcpFrontendRequest, IpLoadbalancingFrontendTcpFrontendTcp, GetIpLoadbalancingTcpFrontendError, OvhOpContext>;
+export type GetIpLoadbalancingTcpRouteError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTcpRoute: API.OperationMethod<GetIpLoadbalancingTcpRouteRequest, IpLoadbalancingRouteTcpRouteTcp, GetIpLoadbalancingTcpRouteError, OvhOpContext>;
+export type GetIpLoadbalancingTcpRouteRuleError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingTcpRouteRule: API.OperationMethod<GetIpLoadbalancingTcpRouteRuleRequest, IpLoadbalancingRouteRuleRouteRule, GetIpLoadbalancingTcpRouteRuleError, OvhOpContext>;
+export type GetIpLoadbalancingUdpFarmError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingUdpFarm: API.OperationMethod<GetIpLoadbalancingUdpFarmRequest, IpLoadbalancingBackendUdpBackendUdp, GetIpLoadbalancingUdpFarmError, OvhOpContext>;
+export type GetIpLoadbalancingUdpFarmServerError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingUdpFarmServer: API.OperationMethod<GetIpLoadbalancingUdpFarmServerRequest, IpLoadbalancingBackendUdpCustomerServerBackendUDPServer, GetIpLoadbalancingUdpFarmServerError, OvhOpContext>;
+export type GetIpLoadbalancingUdpFrontendError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingUdpFrontend: API.OperationMethod<GetIpLoadbalancingUdpFrontendRequest, IpLoadbalancingFrontendUdpFrontendUdp, GetIpLoadbalancingUdpFrontendError, OvhOpContext>;
+export type GetIpLoadbalancingVrackNetworkError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingVrackNetwork: API.OperationMethod<GetIpLoadbalancingVrackNetworkRequest, IpLoadbalancingVrackNetworkVrackNetwork, GetIpLoadbalancingVrackNetworkError, OvhOpContext>;
+export type GetIpLoadbalancingVrackNetworkCreationRulesError = OvhOpError;
+/** Rules to create a network attached to a vrack */
+export declare const getIpLoadbalancingVrackNetworkCreationRules: API.OperationMethod<GetIpLoadbalancingVrackNetworkCreationRulesRequest, IpLoadbalancingVrackNetworkCreationRules, GetIpLoadbalancingVrackNetworkCreationRulesError, OvhOpContext>;
+export type GetIpLoadbalancingZoneError = OvhOpError;
+/** Get this object properties */
+export declare const getIpLoadbalancingZone: API.OperationMethod<GetIpLoadbalancingZoneRequest, IpLoadbalancingZoneZone, GetIpLoadbalancingZoneError, OvhOpContext>;
+export type ListIpLoadbalancingError = OvhOpError;
+/** List of your load balancing IP */
+export declare const listIpLoadbalancing: API.OperationMethod<ListIpLoadbalancingRequest, ListIpLoadbalancingResponse, ListIpLoadbalancingError, OvhOpContext>;
+export type ListIpLoadbalancingAvailableFarmProbesError = OvhOpError;
+/** Available farm probes for health checks */
+export declare const listIpLoadbalancingAvailableFarmProbes: API.OperationMethod<ListIpLoadbalancingAvailableFarmProbesRequest, ListIpLoadbalancingAvailableFarmProbesResponse, ListIpLoadbalancingAvailableFarmProbesError, OvhOpContext>;
+export type ListIpLoadbalancingAvailableFarmTypeError = OvhOpError;
+/** Available farm types */
+export declare const listIpLoadbalancingAvailableFarmType: API.OperationMethod<ListIpLoadbalancingAvailableFarmTypeRequest, ListIpLoadbalancingAvailableFarmTypeResponse, ListIpLoadbalancingAvailableFarmTypeError, OvhOpContext>;
+export type ListIpLoadbalancingAvailableFrontendTypeError = OvhOpError;
+/** Available frontend type */
+export declare const listIpLoadbalancingAvailableFrontendType: API.OperationMethod<ListIpLoadbalancingAvailableFrontendTypeRequest, ListIpLoadbalancingAvailableFrontendTypeResponse, ListIpLoadbalancingAvailableFrontendTypeError, OvhOpContext>;
+export type ListIpLoadbalancingAvailableRouteActionsError = OvhOpError;
+/** Available route actions */
+export declare const listIpLoadbalancingAvailableRouteActions: API.OperationMethod<ListIpLoadbalancingAvailableRouteActionsRequest, ListIpLoadbalancingAvailableRouteActionsResponse, ListIpLoadbalancingAvailableRouteActionsError, OvhOpContext>;
+export type ListIpLoadbalancingAvailableRouteRulesError = OvhOpError;
+/** Available route match rules */
+export declare const listIpLoadbalancingAvailableRouteRules: API.OperationMethod<ListIpLoadbalancingAvailableRouteRulesRequest, ListIpLoadbalancingAvailableRouteRulesResponse, ListIpLoadbalancingAvailableRouteRulesError, OvhOpContext>;
+export type ListIpLoadbalancingDefinedFarmsError = OvhOpError;
+/** List of defined farms, and whether they are HTTP, TCP or UDP */
+export declare const listIpLoadbalancingDefinedFarms: API.OperationMethod<ListIpLoadbalancingDefinedFarmsRequest, ListIpLoadbalancingDefinedFarmsResponse, ListIpLoadbalancingDefinedFarmsError, OvhOpContext>;
+export type ListIpLoadbalancingDefinedFrontendsError = OvhOpError;
+/** List of defined frontends, and whether they are HTTP, TCP or UDP */
+export declare const listIpLoadbalancingDefinedFrontends: API.OperationMethod<ListIpLoadbalancingDefinedFrontendsRequest, ListIpLoadbalancingDefinedFrontendsResponse, ListIpLoadbalancingDefinedFrontendsError, OvhOpContext>;
+export type ListIpLoadbalancingDefinedRoutesError = OvhOpError;
+/** List of defined routes, and whether they are HTTP or TCP */
+export declare const listIpLoadbalancingDefinedRoutes: API.OperationMethod<ListIpLoadbalancingDefinedRoutesRequest, ListIpLoadbalancingDefinedRoutesResponse, ListIpLoadbalancingDefinedRoutesError, OvhOpContext>;
+export type ListIpLoadbalancingFailoverError = OvhOpError;
+/** List all failover ip routed to this IPLB */
+export declare const listIpLoadbalancingFailover: API.OperationMethod<ListIpLoadbalancingFailoverRequest, ListIpLoadbalancingFailoverResponse, ListIpLoadbalancingFailoverError, OvhOpContext>;
+export type ListIpLoadbalancingHttpFarmError = OvhOpError;
+/** HTTP Farm for this iplb */
+export declare const listIpLoadbalancingHttpFarm: API.OperationMethod<ListIpLoadbalancingHttpFarmRequest, ListIpLoadbalancingHttpFarmResponse, ListIpLoadbalancingHttpFarmError, OvhOpContext>;
+export type ListIpLoadbalancingHttpFarmServerError = OvhOpError;
+/** HTTP Farm's Servers */
+export declare const listIpLoadbalancingHttpFarmServer: API.OperationMethod<ListIpLoadbalancingHttpFarmServerRequest, ListIpLoadbalancingHttpFarmServerResponse, ListIpLoadbalancingHttpFarmServerError, OvhOpContext>;
+export type ListIpLoadbalancingHttpFarmServerTransparentError = OvhOpError;
+/** HTTP Farm's Servers transparent configuration */
+export declare const listIpLoadbalancingHttpFarmServerTransparent: API.OperationMethod<ListIpLoadbalancingHttpFarmServerTransparentRequest, ListIpLoadbalancingHttpFarmServerTransparentResponse, ListIpLoadbalancingHttpFarmServerTransparentError, OvhOpContext>;
+export type ListIpLoadbalancingHttpFrontendError = OvhOpError;
+/** HTTP frontends for this iplb */
+export declare const listIpLoadbalancingHttpFrontend: API.OperationMethod<ListIpLoadbalancingHttpFrontendRequest, ListIpLoadbalancingHttpFrontendResponse, ListIpLoadbalancingHttpFrontendError, OvhOpContext>;
+export type ListIpLoadbalancingHttpRouteError = OvhOpError;
+/** HTTP routes for this iplb */
+export declare const listIpLoadbalancingHttpRoute: API.OperationMethod<ListIpLoadbalancingHttpRouteRequest, ListIpLoadbalancingHttpRouteResponse, ListIpLoadbalancingHttpRouteError, OvhOpContext>;
+export type ListIpLoadbalancingHttpRouteRuleError = OvhOpError;
+/** HTTP routes for this iplb */
+export declare const listIpLoadbalancingHttpRouteRule: API.OperationMethod<ListIpLoadbalancingHttpRouteRuleRequest, ListIpLoadbalancingHttpRouteRuleResponse, ListIpLoadbalancingHttpRouteRuleError, OvhOpContext>;
+export type ListIpLoadbalancingLogKindError = OvhOpError;
+/** Log kinds for your Load Balancer */
+export declare const listIpLoadbalancingLogKind: API.OperationMethod<ListIpLoadbalancingLogKindRequest, ListIpLoadbalancingLogKindResponse, ListIpLoadbalancingLogKindError, OvhOpContext>;
+export type ListIpLoadbalancingLogSubscriptionError = OvhOpError;
+/** Log subscriptions for your Load Balancer */
+export declare const listIpLoadbalancingLogSubscription: API.OperationMethod<ListIpLoadbalancingLogSubscriptionRequest, ListIpLoadbalancingLogSubscriptionResponse, ListIpLoadbalancingLogSubscriptionError, OvhOpContext>;
+export type ListIpLoadbalancingNatIpError = OvhOpError;
+/** 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 declare const listIpLoadbalancingNatIp: API.OperationMethod<ListIpLoadbalancingNatIpRequest, ListIpLoadbalancingNatIpResponse, ListIpLoadbalancingNatIpError, OvhOpContext>;
+export type ListIpLoadbalancingPendingChangesError = OvhOpError;
+/** List the pending changes on your Load Balancer configuration, per zone */
+export declare const listIpLoadbalancingPendingChanges: API.OperationMethod<ListIpLoadbalancingPendingChangesRequest, ListIpLoadbalancingPendingChangesResponse, ListIpLoadbalancingPendingChangesError, OvhOpContext>;
+export type ListIpLoadbalancingQuotaError = OvhOpError;
+/** Available quota informations for current billing period per zone */
+export declare const listIpLoadbalancingQuota: API.OperationMethod<ListIpLoadbalancingQuotaRequest, ListIpLoadbalancingQuotaResponse, ListIpLoadbalancingQuotaError, OvhOpContext>;
+export type ListIpLoadbalancingQuotaHistoryError = OvhOpError;
+/** Quota history informations, per month */
+export declare const listIpLoadbalancingQuotaHistory: API.OperationMethod<ListIpLoadbalancingQuotaHistoryRequest, ListIpLoadbalancingQuotaHistoryResponse, ListIpLoadbalancingQuotaHistoryError, OvhOpContext>;
+export type ListIpLoadbalancingSslError = OvhOpError;
+/** Ssl for this iplb */
+export declare const listIpLoadbalancingSsl: API.OperationMethod<ListIpLoadbalancingSslRequest, ListIpLoadbalancingSslResponse, ListIpLoadbalancingSslError, OvhOpContext>;
+export type ListIpLoadbalancingTaskError = OvhOpError;
+/** Task for this iplb */
+export declare const listIpLoadbalancingTask: API.OperationMethod<ListIpLoadbalancingTaskRequest, ListIpLoadbalancingTaskResponse, ListIpLoadbalancingTaskError, OvhOpContext>;
+export type ListIpLoadbalancingTcpFarmError = OvhOpError;
+/** TCP Farm for this iplb */
+export declare const listIpLoadbalancingTcpFarm: API.OperationMethod<ListIpLoadbalancingTcpFarmRequest, ListIpLoadbalancingTcpFarmResponse, ListIpLoadbalancingTcpFarmError, OvhOpContext>;
+export type ListIpLoadbalancingTcpFarmServerError = OvhOpError;
+/** TCP Farm's Servers */
+export declare const listIpLoadbalancingTcpFarmServer: API.OperationMethod<ListIpLoadbalancingTcpFarmServerRequest, ListIpLoadbalancingTcpFarmServerResponse, ListIpLoadbalancingTcpFarmServerError, OvhOpContext>;
+export type ListIpLoadbalancingTcpFarmServerTransparentError = OvhOpError;
+/** TCP Farm's Servers transparent configuration */
+export declare const listIpLoadbalancingTcpFarmServerTransparent: API.OperationMethod<ListIpLoadbalancingTcpFarmServerTransparentRequest, ListIpLoadbalancingTcpFarmServerTransparentResponse, ListIpLoadbalancingTcpFarmServerTransparentError, OvhOpContext>;
+export type ListIpLoadbalancingTcpFrontendError = OvhOpError;
+/** TCP frontends for this iplb */
+export declare const listIpLoadbalancingTcpFrontend: API.OperationMethod<ListIpLoadbalancingTcpFrontendRequest, ListIpLoadbalancingTcpFrontendResponse, ListIpLoadbalancingTcpFrontendError, OvhOpContext>;
+export type ListIpLoadbalancingTcpRouteError = OvhOpError;
+/** TCP routes for this iplb */
+export declare const listIpLoadbalancingTcpRoute: API.OperationMethod<ListIpLoadbalancingTcpRouteRequest, ListIpLoadbalancingTcpRouteResponse, ListIpLoadbalancingTcpRouteError, OvhOpContext>;
+export type ListIpLoadbalancingTcpRouteRuleError = OvhOpError;
+/** HTTP routes for this iplb */
+export declare const listIpLoadbalancingTcpRouteRule: API.OperationMethod<ListIpLoadbalancingTcpRouteRuleRequest, ListIpLoadbalancingTcpRouteRuleResponse, ListIpLoadbalancingTcpRouteRuleError, OvhOpContext>;
+export type ListIpLoadbalancingUdpFarmError = OvhOpError;
+/** UDP Farm for this iplb */
+export declare const listIpLoadbalancingUdpFarm: API.OperationMethod<ListIpLoadbalancingUdpFarmRequest, ListIpLoadbalancingUdpFarmResponse, ListIpLoadbalancingUdpFarmError, OvhOpContext>;
+export type ListIpLoadbalancingUdpFarmServerError = OvhOpError;
+/** UDP Farm's Servers */
+export declare const listIpLoadbalancingUdpFarmServer: API.OperationMethod<ListIpLoadbalancingUdpFarmServerRequest, ListIpLoadbalancingUdpFarmServerResponse, ListIpLoadbalancingUdpFarmServerError, OvhOpContext>;
+export type ListIpLoadbalancingUdpFrontendError = OvhOpError;
+/** UDP frontends for this iplb */
+export declare const listIpLoadbalancingUdpFrontend: API.OperationMethod<ListIpLoadbalancingUdpFrontendRequest, ListIpLoadbalancingUdpFrontendResponse, ListIpLoadbalancingUdpFrontendError, OvhOpContext>;
+export type ListIpLoadbalancingVrackNetworkError = OvhOpError;
+/** Descriptions of private networks in the vRack attached to this Load Balancer */
+export declare const listIpLoadbalancingVrackNetwork: API.OperationMethod<ListIpLoadbalancingVrackNetworkRequest, ListIpLoadbalancingVrackNetworkResponse, ListIpLoadbalancingVrackNetworkError, OvhOpContext>;
+export type ListIpLoadbalancingVrackStatusError = OvhOpError;
+/** Information about vRack for your Load Balancer */
+export declare const listIpLoadbalancingVrackStatus: API.OperationMethod<ListIpLoadbalancingVrackStatusRequest, IpLoadbalancingVrackInformation, ListIpLoadbalancingVrackStatusError, OvhOpContext>;
+export type ListIpLoadbalancingVrackTransparentGatewaysError = OvhOpError;
+/** Get gateways for configured vrack transparent ip */
+export declare const listIpLoadbalancingVrackTransparentGateways: API.OperationMethod<ListIpLoadbalancingVrackTransparentGatewaysRequest, ListIpLoadbalancingVrackTransparentGatewaysResponse, ListIpLoadbalancingVrackTransparentGatewaysError, OvhOpContext>;
+export type ListIpLoadbalancingZoneError = OvhOpError;
+/** Zone for this iplb */
+export declare const listIpLoadbalancingZone: API.OperationMethod<ListIpLoadbalancingZoneRequest, ListIpLoadbalancingZoneResponse, ListIpLoadbalancingZoneError, OvhOpContext>;
+export type PutIpLoadbalancingError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancing: API.OperationMethod<PutIpLoadbalancingRequest, PutIpLoadbalancingResponse, PutIpLoadbalancingError, OvhOpContext>;
+export type PutIpLoadbalancingHttpFarmError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingHttpFarm: API.OperationMethod<PutIpLoadbalancingHttpFarmRequest, PutIpLoadbalancingHttpFarmResponse, PutIpLoadbalancingHttpFarmError, OvhOpContext>;
+export type PutIpLoadbalancingHttpFarmServerError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingHttpFarmServer: API.OperationMethod<PutIpLoadbalancingHttpFarmServerRequest, PutIpLoadbalancingHttpFarmServerResponse, PutIpLoadbalancingHttpFarmServerError, OvhOpContext>;
+export type PutIpLoadbalancingHttpFrontendError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingHttpFrontend: API.OperationMethod<PutIpLoadbalancingHttpFrontendRequest, PutIpLoadbalancingHttpFrontendResponse, PutIpLoadbalancingHttpFrontendError, OvhOpContext>;
+export type PutIpLoadbalancingHttpRouteError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingHttpRoute: API.OperationMethod<PutIpLoadbalancingHttpRouteRequest, PutIpLoadbalancingHttpRouteResponse, PutIpLoadbalancingHttpRouteError, OvhOpContext>;
+export type PutIpLoadbalancingHttpRouteRuleError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingHttpRouteRule: API.OperationMethod<PutIpLoadbalancingHttpRouteRuleRequest, PutIpLoadbalancingHttpRouteRuleResponse, PutIpLoadbalancingHttpRouteRuleError, OvhOpContext>;
+export type PutIpLoadbalancingQuotaError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingQuota: API.OperationMethod<PutIpLoadbalancingQuotaRequest, PutIpLoadbalancingQuotaResponse, PutIpLoadbalancingQuotaError, OvhOpContext>;
+export type PutIpLoadbalancingServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putIpLoadbalancingServiceInfos: API.OperationMethod<PutIpLoadbalancingServiceInfosRequest, PutIpLoadbalancingServiceInfosResponse, PutIpLoadbalancingServiceInfosError, OvhOpContext>;
+export type PutIpLoadbalancingSslError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingSsl: API.OperationMethod<PutIpLoadbalancingSslRequest, PutIpLoadbalancingSslResponse, PutIpLoadbalancingSslError, OvhOpContext>;
+export type PutIpLoadbalancingTcpFarmError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingTcpFarm: API.OperationMethod<PutIpLoadbalancingTcpFarmRequest, PutIpLoadbalancingTcpFarmResponse, PutIpLoadbalancingTcpFarmError, OvhOpContext>;
+export type PutIpLoadbalancingTcpFarmServerError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingTcpFarmServer: API.OperationMethod<PutIpLoadbalancingTcpFarmServerRequest, PutIpLoadbalancingTcpFarmServerResponse, PutIpLoadbalancingTcpFarmServerError, OvhOpContext>;
+export type PutIpLoadbalancingTcpFrontendError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingTcpFrontend: API.OperationMethod<PutIpLoadbalancingTcpFrontendRequest, PutIpLoadbalancingTcpFrontendResponse, PutIpLoadbalancingTcpFrontendError, OvhOpContext>;
+export type PutIpLoadbalancingTcpRouteError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingTcpRoute: API.OperationMethod<PutIpLoadbalancingTcpRouteRequest, PutIpLoadbalancingTcpRouteResponse, PutIpLoadbalancingTcpRouteError, OvhOpContext>;
+export type PutIpLoadbalancingTcpRouteRuleError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingTcpRouteRule: API.OperationMethod<PutIpLoadbalancingTcpRouteRuleRequest, PutIpLoadbalancingTcpRouteRuleResponse, PutIpLoadbalancingTcpRouteRuleError, OvhOpContext>;
+export type PutIpLoadbalancingUdpFarmError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingUdpFarm: API.OperationMethod<PutIpLoadbalancingUdpFarmRequest, PutIpLoadbalancingUdpFarmResponse, PutIpLoadbalancingUdpFarmError, OvhOpContext>;
+export type PutIpLoadbalancingUdpFarmServerError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingUdpFarmServer: API.OperationMethod<PutIpLoadbalancingUdpFarmServerRequest, PutIpLoadbalancingUdpFarmServerResponse, PutIpLoadbalancingUdpFarmServerError, OvhOpContext>;
+export type PutIpLoadbalancingUdpFrontendError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingUdpFrontend: API.OperationMethod<PutIpLoadbalancingUdpFrontendRequest, PutIpLoadbalancingUdpFrontendResponse, PutIpLoadbalancingUdpFrontendError, OvhOpContext>;
+export type PutIpLoadbalancingVrackNetworkError = OvhOpError;
+/** Alter this object properties */
+export declare const putIpLoadbalancingVrackNetwork: API.OperationMethod<PutIpLoadbalancingVrackNetworkRequest, PutIpLoadbalancingVrackNetworkResponse, PutIpLoadbalancingVrackNetworkError, OvhOpContext>;
+export type RefreshIpLoadbalancingError = OvhOpError;
+/** Apply the configuration to your iplb */
+export declare const refreshIpLoadbalancing: API.OperationMethod<RefreshIpLoadbalancingRequest, IpLoadbalancingTaskTask, RefreshIpLoadbalancingError, OvhOpContext>;
+export type TerminateIpLoadbalancingError = OvhOpError;
+/** Ask for the termination of your service Ask for the termination of your service. Admin contact of this service will receive a termination token by email in order to confirm its termination with /confirmTermination endpoint. */
+export declare const terminateIpLoadbalancing: API.OperationMethod<TerminateIpLoadbalancingRequest, TerminateIpLoadbalancingResponse, TerminateIpLoadbalancingError, OvhOpContext>;
+export type TerminateIpLoadbalancingZoneError = OvhOpError;
+/** Terminate your service zone option */
+export declare const terminateIpLoadbalancingZone: API.OperationMethod<TerminateIpLoadbalancingZoneRequest, TerminateIpLoadbalancingZoneResponse, TerminateIpLoadbalancingZoneError, OvhOpContext>;
+export type UpdateIpLoadbalancingVrackNetworkFarmIdError = OvhOpError;
+/** Update farm attached to that vrack network id */
+export declare const updateIpLoadbalancingVrackNetworkFarmId: API.OperationMethod<UpdateIpLoadbalancingVrackNetworkFarmIdRequest, IpLoadbalancingVrackNetworkVrackNetwork, UpdateIpLoadbalancingVrackNetworkFarmIdError, OvhOpContext>;
+//# sourceMappingURL=iploadbalancing.d.ts.map