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

package/lib/services/overthebox.d.ts

@@ -0,0 +1,981 @@
+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 AuthorizeOverTheBoxRemoteAccessRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the remote access */
+    remoteAccessId: string;
+}
+export declare const AuthorizeOverTheBoxRemoteAccessRequest: S.Schema<AuthorizeOverTheBoxRemoteAccessRequest>;
+export interface AuthorizeOverTheBoxRemoteAccessResponse {
+}
+export declare const AuthorizeOverTheBoxRemoteAccessResponse: S.Schema<AuthorizeOverTheBoxRemoteAccessResponse>;
+export interface CancelOverTheBoxResiliationRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const CancelOverTheBoxResiliationRequest: S.Schema<CancelOverTheBoxResiliationRequest>;
+export interface CancelOverTheBoxResiliationResponse {
+}
+export declare const CancelOverTheBoxResiliationResponse: S.Schema<CancelOverTheBoxResiliationResponse>;
+export interface CreateOverTheBoxChangeContactRequest {
+    /** The internal name of your overTheBox offer */
+    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 CreateOverTheBoxChangeContactRequest: S.Schema<CreateOverTheBoxChangeContactRequest>;
+export type CreateOverTheBoxChangeContactResponseBodyList = Array<number>;
+export declare const CreateOverTheBoxChangeContactResponseBodyList: S.Schema<CreateOverTheBoxChangeContactResponseBodyList>;
+export type CreateOverTheBoxChangeContactResponse = CreateOverTheBoxChangeContactResponseBodyList;
+export declare const CreateOverTheBoxChangeContactResponse: S.Schema<CreateOverTheBoxChangeContactResponse>;
+export interface CreateOverTheBoxDeviceRequest {
+}
+export declare const CreateOverTheBoxDeviceRequest: S.Schema<CreateOverTheBoxDeviceRequest>;
+/** A device for registration */
+export interface OverTheBoxDeviceForRegistration {
+    /** Whether or not this device is actived */
+    activated?: boolean;
+    deviceId?: string;
+    /** The last time this device was seen on the provisionning servers */
+    lastSeen?: string;
+}
+export declare const OverTheBoxDeviceForRegistration: S.Schema<OverTheBoxDeviceForRegistration>;
+export type CreateOverTheBoxDeviceResponseBodyList = Array<OverTheBoxDeviceForRegistration>;
+export declare const CreateOverTheBoxDeviceResponseBodyList: S.Schema<CreateOverTheBoxDeviceResponseBodyList>;
+export type CreateOverTheBoxDeviceResponse = CreateOverTheBoxDeviceResponseBodyList;
+export declare const CreateOverTheBoxDeviceResponse: S.Schema<CreateOverTheBoxDeviceResponse>;
+export interface CreateOverTheBoxDeviceActionRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Name of the action */
+    name: string;
+}
+export declare const CreateOverTheBoxDeviceActionRequest: S.Schema<CreateOverTheBoxDeviceActionRequest>;
+/** Status of a task. */
+export type OverTheBoxActionStatusEnum = "doing" | "done" | "error" | "todo";
+export declare const OverTheBoxActionStatusEnum: any;
+/** Device action */
+export interface OverTheBoxDeviceAction {
+    /** The id of the action */
+    actionId?: string;
+    /** Date of creation of the action */
+    createdAt?: string;
+    /** The details of the action */
+    details?: string;
+    /** The name of the action */
+    name?: string;
+    /** The status of the action */
+    status?: OverTheBoxActionStatusEnum;
+    /** Date of execution of the action */
+    todoDate?: string;
+    /** Last time the action was updated */
+    updatedAt?: string;
+}
+export declare const OverTheBoxDeviceAction: S.Schema<OverTheBoxDeviceAction>;
+export interface CreateOverTheBoxDeviceBackupRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const CreateOverTheBoxDeviceBackupRequest: S.Schema<CreateOverTheBoxDeviceBackupRequest>;
+export interface CreateOverTheBoxDeviceLogRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const CreateOverTheBoxDeviceLogRequest: S.Schema<CreateOverTheBoxDeviceLogRequest>;
+/** Temporary url informations */
+export interface OverTheBoxTemporaryLogsLink {
+    /** Temporary url expiration date */
+    expirationDate?: string;
+    /** Temporary url */
+    url?: string;
+}
+export declare const OverTheBoxTemporaryLogsLink: S.Schema<OverTheBoxTemporaryLogsLink>;
+export interface CreateOverTheBoxLinkDeviceRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the device */
+    deviceId: string;
+}
+export declare const CreateOverTheBoxLinkDeviceRequest: S.Schema<CreateOverTheBoxLinkDeviceRequest>;
+export interface CreateOverTheBoxLinkDeviceResponse {
+}
+export declare const CreateOverTheBoxLinkDeviceResponse: S.Schema<CreateOverTheBoxLinkDeviceResponse>;
+export interface CreateOverTheBoxLinkHardwareRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The internal name of your hardware */
+    hardwareName: string;
+}
+export declare const CreateOverTheBoxLinkHardwareRequest: S.Schema<CreateOverTheBoxLinkHardwareRequest>;
+export interface CreateOverTheBoxLinkHardwareResponse {
+}
+export declare const CreateOverTheBoxLinkHardwareResponse: S.Schema<CreateOverTheBoxLinkHardwareResponse>;
+export interface CreateOverTheBoxMigrationChangeOfferRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Name of the hardware */
+    hardwareName?: string;
+    /** Offer name to migrate to */
+    offer: string;
+    /** In case of hardware and if a shipping custom address is desired */
+    shippingContactID?: string;
+}
+export declare const CreateOverTheBoxMigrationChangeOfferRequest: S.Schema<CreateOverTheBoxMigrationChangeOfferRequest>;
+/** Migration order */
+export interface OverTheBoxOrderMigration {
+    /** Id of the migration order */
+    orderId?: string;
+    /** URL of the migration order */
+    orderUrl?: string;
+}
+export declare const OverTheBoxOrderMigration: S.Schema<OverTheBoxOrderMigration>;
+export interface CreateOverTheBoxRemoteAccessRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** IP block from which the remote access will be allowed (the default value is the IP from which the call is made) */
+    allowedIp?: string;
+    /** The expirationDate of the remote access (default 1 day) */
+    expirationDate?: string;
+    /** The port that the device will expose */
+    exposedPort: number;
+    /** The remote user public key authorized on the device (for SSH purpose) */
+    publicKey?: string;
+}
+export declare const CreateOverTheBoxRemoteAccessRequest: S.Schema<CreateOverTheBoxRemoteAccessRequest>;
+/** All the infos needed to connect yourself to your OTB */
+export interface OverTheBoxRemoteAccessConnectionInfos {
+    /** IP to connect to when accessing the device remotely */
+    ip?: string | null;
+    /** Port to connect to when accessing the device remotely */
+    port?: number | null;
+}
+export declare const OverTheBoxRemoteAccessConnectionInfos: S.Schema<OverTheBoxRemoteAccessConnectionInfos>;
+/** Infos about the remote user */
+export interface OverTheBoxRemoteAccessUserInfos {
+    /** IP from which the remote access will be allowed */
+    ip?: string;
+    /** The public key authorized on the device (for SSH purpose) */
+    publicKey?: string | null;
+    /** The user that will access the device remotely */
+    user?: string;
+}
+export declare const OverTheBoxRemoteAccessUserInfos: S.Schema<OverTheBoxRemoteAccessUserInfos>;
+/** Status of the remote access. */
+export type OverTheBoxRemoteAccessStatusEnum = "active" | "creating" | "deleted" | "deleting" | "pendingValidation" | "recreating" | "toDelete" | "toRecreate";
+export declare const OverTheBoxRemoteAccessStatusEnum: any;
+/** If authorized, a remote access will expose a port, allowing an access to the device remotely */
+export interface OverTheBoxRemoteAccess {
+    /** If the remote access was accepted by the remote user */
+    accepted?: boolean;
+    /** The date of the remote access demand */
+    askDate?: string;
+    /** The user that authorized the remote access */
+    authorizedBy?: string | null;
+    /** All the infos needed to connect yourself to your OTB */
+    connectionInfos?: OverTheBoxRemoteAccessConnectionInfos;
+    /** When the remote access was deleted */
+    deletedAt?: string | null;
+    /** Info about the docker version */
+    dockerVersion?: string;
+    /** When the remote access will be automatically deleted */
+    expirationDate?: string;
+    /** The device's port which will be exposed */
+    exposedPort?: number;
+    /** The id of the remote access */
+    remoteAccessId?: string;
+    /** Infos about the remote user */
+    remoteUserInfos?: OverTheBoxRemoteAccessUserInfos;
+    /** Status of the remote access */
+    status?: OverTheBoxRemoteAccessStatusEnum;
+}
+export declare const OverTheBoxRemoteAccess: S.Schema<OverTheBoxRemoteAccess>;
+export interface DeleteOverTheBoxRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const DeleteOverTheBoxRequest: S.Schema<DeleteOverTheBoxRequest>;
+export interface DeleteOverTheBoxResponse {
+}
+export declare const DeleteOverTheBoxResponse: S.Schema<DeleteOverTheBoxResponse>;
+export interface DeleteOverTheBoxBackupRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the backup */
+    backupId: string;
+}
+export declare const DeleteOverTheBoxBackupRequest: S.Schema<DeleteOverTheBoxBackupRequest>;
+export interface DeleteOverTheBoxBackupResponse {
+}
+export declare const DeleteOverTheBoxBackupResponse: S.Schema<DeleteOverTheBoxBackupResponse>;
+export interface DeleteOverTheBoxDeviceRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const DeleteOverTheBoxDeviceRequest: S.Schema<DeleteOverTheBoxDeviceRequest>;
+export interface DeleteOverTheBoxDeviceResponse {
+}
+export declare const DeleteOverTheBoxDeviceResponse: S.Schema<DeleteOverTheBoxDeviceResponse>;
+export interface DeleteOverTheBoxRemoteAccessRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the remote access */
+    remoteAccessId: string;
+}
+export declare const DeleteOverTheBoxRemoteAccessRequest: S.Schema<DeleteOverTheBoxRemoteAccessRequest>;
+export interface DeleteOverTheBoxRemoteAccessResponse {
+}
+export declare const DeleteOverTheBoxRemoteAccessResponse: S.Schema<DeleteOverTheBoxRemoteAccessResponse>;
+export interface GetOverTheBoxRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const GetOverTheBoxRequest: S.Schema<GetOverTheBoxRequest>;
+/** Status of the service */
+export type OverTheBoxAvailableStatusEnum = "disabled" | "enabled";
+export declare const OverTheBoxAvailableStatusEnum: any;
+/** Configuration mode of the service */
+export type OverTheBoxServiceConfigurationModeEnum = "autoconfigure" | "local";
+export declare const OverTheBoxServiceConfigurationModeEnum: any;
+/** Parameters required to query metrics from OpenTSDB */
+export interface OverTheBoxGraphEndpoint {
+    /** The OpenTSDB host */
+    host?: string;
+    /** A read-only token */
+    readToken?: string;
+    /** The read-only token ID */
+    readTokenID?: string;
+}
+export declare const OverTheBoxGraphEndpoint: S.Schema<OverTheBoxGraphEndpoint>;
+/** 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>;
+/** Status of the service. */
+export type OverTheBoxServiceStatusEnum = "active" | "creating" | "deleted" | "suspended" | "toCreate" | "toDelete";
+export declare const OverTheBoxServiceStatusEnum: any;
+/** Tunnel mode of the service. */
+export type OverTheBoxTunnelModeEnum = "glorytun" | "glorytun_hybrid" | "glorytun_mud";
+export declare const OverTheBoxTunnelModeEnum: any;
+/** Service */
+export interface OverTheBoxServiceWithIAM {
+    /** If the socks proxy is enabled */
+    SOCKSProxyEnabled?: boolean;
+    /** The status of the autoMTU */
+    autoMTU?: OverTheBoxAvailableStatusEnum;
+    /** Enable device auto upgrade */
+    autoUpgrade?: boolean;
+    /** The service maximum bandwidth in bits */
+    bandwidth?: number;
+    /** Configuration mode of the service */
+    configurationMode?: OverTheBoxServiceConfigurationModeEnum;
+    /** Editable field for customer */
+    customerDescription?: string | null;
+    /** Parameters needed to fetch metrics */
+    graphEndpoint?: OverTheBoxGraphEndpoint | null;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Indicates if IPv6 is enabled */
+    ipv6Enabled?: boolean;
+    /** The service offer */
+    offer?: string;
+    /** The service pretty offer name */
+    prettyOfferName?: string;
+    /** Release channel of the service */
+    releaseChannel?: string;
+    /** The name of the service */
+    serviceName?: string;
+    /** The status of the service */
+    status?: OverTheBoxServiceStatusEnum;
+    /** The tunnel mode of the service */
+    tunnelMode?: OverTheBoxTunnelModeEnum;
+}
+export declare const OverTheBoxServiceWithIAM: S.Schema<OverTheBoxServiceWithIAM>;
+export interface GetOverTheBoxBackupRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the backup */
+    backupId: string;
+}
+export declare const GetOverTheBoxBackupRequest: S.Schema<GetOverTheBoxBackupRequest>;
+/** Backup */
+export interface OverTheBoxBackup {
+    /** The id of the backup */
+    backupId?: string;
+    /** Date of the creation of the backup */
+    createdAt?: string;
+    /** The id of the device action that triggered the backup */
+    deviceActionId?: string | null;
+}
+export declare const OverTheBoxBackup: S.Schema<OverTheBoxBackup>;
+export interface GetOverTheBoxDeviceRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const GetOverTheBoxDeviceRequest: S.Schema<GetOverTheBoxDeviceRequest>;
+/** The DNS servers of this interface */
+export type OverTheBoxDeviceInterfaceDnsServersList = Array<string>;
+export declare const OverTheBoxDeviceInterfaceDnsServersList: S.Schema<OverTheBoxDeviceInterfaceDnsServersList>;
+/** Status of a MPTCP Interface. */
+export type OverTheBoxMultipathStatusEnum = "backup" | "handover" | "master" | "off" | "on";
+export declare const OverTheBoxMultipathStatusEnum: any;
+/** Infos about a network interface */
+export interface OverTheBoxDeviceInterface {
+    /** Device of the interface */
+    device?: string | null;
+    /** The DNS servers of this interface */
+    dnsServers?: OverTheBoxDeviceInterfaceDnsServersList | null;
+    /** Gateway of the interface */
+    gateway?: string | null;
+    /** IP of the interface */
+    ip?: string | null;
+    /** Status of MPTCP on this interface */
+    multipathStatus?: OverTheBoxMultipathStatusEnum;
+    /** Name of the interface */
+    name?: string;
+    /** Netmask of the interface */
+    netmask?: string | null;
+    /** Public IP of the interface */
+    publicIp?: string | null;
+}
+export declare const OverTheBoxDeviceInterface: S.Schema<OverTheBoxDeviceInterface>;
+/** Network interfaces of the device */
+export type OverTheBoxDeviceNetworkInterfacesList = Array<OverTheBoxDeviceInterface>;
+export declare const OverTheBoxDeviceNetworkInterfacesList: S.Schema<OverTheBoxDeviceNetworkInterfacesList>;
+/** Infos about a device system */
+export interface OverTheBoxDeviceSystem {
+    /** Device CPU */
+    cpu?: string | null;
+    /** Device hostname */
+    hostname?: string | null;
+    /** Device linux kernel version */
+    kernel?: string | null;
+    /** Device mac address (first interface mac) */
+    mac?: string | null;
+    /** Device model */
+    model?: string | null;
+    /** Name of the device board */
+    name?: string | null;
+    /** OVH offer name of the device board */
+    offerName?: string | null;
+    /** OVH name of the device board */
+    ovhName?: string | null;
+}
+export declare const OverTheBoxDeviceSystem: S.Schema<OverTheBoxDeviceSystem>;
+/** Device */
+export interface OverTheBoxDevice {
+    /** Whether or not this device is associated to a service */
+    activated?: boolean;
+    /** Whether or not an upate is available for this device */
+    availableUpdate?: boolean;
+    /** The id of the device */
+    deviceId?: string;
+    /** Last time the device has been seen on the provisionning servers */
+    lastSeen?: string;
+    /** Network interfaces of the device */
+    networkInterfaces?: OverTheBoxDeviceNetworkInterfacesList;
+    /** The public IP of the device */
+    publicIp?: string;
+    /** Device system information */
+    system?: OverTheBoxDeviceSystem | null;
+    /** System version of the device */
+    systemVersion?: string;
+    /** Version of the device */
+    version?: string;
+}
+export declare const OverTheBoxDevice: S.Schema<OverTheBoxDevice>;
+export interface GetOverTheBoxDeviceActionRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the action */
+    actionId: string;
+}
+export declare const GetOverTheBoxDeviceActionRequest: S.Schema<GetOverTheBoxDeviceActionRequest>;
+export interface GetOverTheBoxDeviceHardwareRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const GetOverTheBoxDeviceHardwareRequest: S.Schema<GetOverTheBoxDeviceHardwareRequest>;
+/** Hardware properties */
+export interface OverTheBoxHardware {
+    /** True if hardware can be linked to a service without deviceID */
+    canBeLinkedToService?: boolean;
+    /** Hardware MAC address */
+    mac?: string | null;
+    /** Hardware model */
+    model?: string;
+    /** Hardware name */
+    name?: string;
+    /** The hardware pretty model name */
+    prettyModelName?: string;
+    /** Hardware serial */
+    serial?: string;
+}
+export declare const OverTheBoxHardware: S.Schema<OverTheBoxHardware>;
+export interface GetOverTheBoxHardwareRequest {
+    /** The internal name of your hardware */
+    hardwareName: string;
+}
+export declare const GetOverTheBoxHardwareRequest: S.Schema<GetOverTheBoxHardwareRequest>;
+/** Hardware properties */
+export interface OverTheBoxHardwareWithIAM {
+    /** True if hardware can be linked to a service without deviceID */
+    canBeLinkedToService?: boolean;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Hardware MAC address */
+    mac?: string | null;
+    /** Hardware model */
+    model?: string;
+    /** Hardware name */
+    name?: string;
+    /** The hardware pretty model name */
+    prettyModelName?: string;
+    /** Hardware serial */
+    serial?: string;
+}
+export declare const OverTheBoxHardwareWithIAM: S.Schema<OverTheBoxHardwareWithIAM>;
+export interface GetOverTheBoxIpsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const GetOverTheBoxIpsRequest: S.Schema<GetOverTheBoxIpsRequest>;
+/** IP geolocation */
+export type OtbServiceIpGeolocationEnum = "fr";
+export declare const OtbServiceIpGeolocationEnum: any;
+/** IP status */
+export type OtbServiceIpStatusEnum = "active" | "free" | "pendingRelease" | "released" | "reserved";
+export declare const OtbServiceIpStatusEnum: any;
+/** IP version */
+export type OtbServiceIpVersionEnum = "v4" | "v6";
+export declare const OtbServiceIpVersionEnum: any;
+/** Service IP details */
+export interface OtbServiceIp {
+    /** IP geolocation */
+    geolocation?: OtbServiceIpGeolocationEnum;
+    /** IP address */
+    ip?: string;
+    /** IP cidr prefix */
+    range?: number;
+    /** IP status */
+    status?: OtbServiceIpStatusEnum;
+    /** IP version */
+    version?: OtbServiceIpVersionEnum;
+}
+export declare const OtbServiceIp: S.Schema<OtbServiceIp>;
+export interface GetOverTheBoxRemoteAccessRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the remote access */
+    remoteAccessId: string;
+}
+export declare const GetOverTheBoxRemoteAccessRequest: S.Schema<GetOverTheBoxRemoteAccessRequest>;
+export interface GetOverTheBoxServiceInfosRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const GetOverTheBoxServiceInfosRequest: S.Schema<GetOverTheBoxServiceInfosRequest>;
+/** 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 GetOverTheBoxTaskRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the task */
+    taskId: string;
+}
+export declare const GetOverTheBoxTaskRequest: S.Schema<GetOverTheBoxTaskRequest>;
+/** Status of a task. */
+export type OverTheBoxTaskStatusEnum = "doing" | "done" | "error" | "todo";
+export declare const OverTheBoxTaskStatusEnum: any;
+/** Task */
+export interface OverTheBoxTask {
+    /** The name of the task */
+    name?: string;
+    /** The status of the task */
+    status?: OverTheBoxTaskStatusEnum;
+    /** The id of the task */
+    taskId?: string;
+}
+export declare const OverTheBoxTask: S.Schema<OverTheBoxTask>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListOverTheBoxRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListOverTheBoxRequestIamTagsValueList: S.Schema<ListOverTheBoxRequestIamTagsValueList>;
+export type ListOverTheBoxRequestIamTagsMap = {
+    [key: string]: ListOverTheBoxRequestIamTagsValueList | undefined;
+};
+export declare const ListOverTheBoxRequestIamTagsMap: S.Schema<ListOverTheBoxRequestIamTagsMap>;
+export interface ListOverTheBoxRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListOverTheBoxRequestIamTagsMap;
+}
+export declare const ListOverTheBoxRequest: S.Schema<ListOverTheBoxRequest>;
+export type ListOverTheBoxResponseBodyList = Array<string>;
+export declare const ListOverTheBoxResponseBodyList: S.Schema<ListOverTheBoxResponseBodyList>;
+export type ListOverTheBoxResponse = ListOverTheBoxResponseBodyList;
+export declare const ListOverTheBoxResponse: S.Schema<ListOverTheBoxResponse>;
+export interface ListOverTheBoxAvailableOffersRequest {
+}
+export declare const ListOverTheBoxAvailableOffersRequest: S.Schema<ListOverTheBoxAvailableOffersRequest>;
+/** Enum of Offers */
+export type PriceOverTheBoxOfferEnum = "business.v1" | "plus.v1" | "starter.v1";
+export declare const PriceOverTheBoxOfferEnum: any;
+export type ListOverTheBoxAvailableOffersResponseBodyList = Array<PriceOverTheBoxOfferEnum>;
+export declare const ListOverTheBoxAvailableOffersResponseBodyList: S.Schema<ListOverTheBoxAvailableOffersResponseBodyList>;
+export type ListOverTheBoxAvailableOffersResponse = ListOverTheBoxAvailableOffersResponseBodyList;
+export declare const ListOverTheBoxAvailableOffersResponse: S.Schema<ListOverTheBoxAvailableOffersResponse>;
+export interface ListOverTheBoxAvailableReleaseChannelsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const ListOverTheBoxAvailableReleaseChannelsRequest: S.Schema<ListOverTheBoxAvailableReleaseChannelsRequest>;
+export type ListOverTheBoxAvailableReleaseChannelsResponseBodyList = Array<string>;
+export declare const ListOverTheBoxAvailableReleaseChannelsResponseBodyList: S.Schema<ListOverTheBoxAvailableReleaseChannelsResponseBodyList>;
+export type ListOverTheBoxAvailableReleaseChannelsResponse = ListOverTheBoxAvailableReleaseChannelsResponseBodyList;
+export declare const ListOverTheBoxAvailableReleaseChannelsResponse: S.Schema<ListOverTheBoxAvailableReleaseChannelsResponse>;
+export interface ListOverTheBoxBackupsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const ListOverTheBoxBackupsRequest: S.Schema<ListOverTheBoxBackupsRequest>;
+export type ListOverTheBoxBackupsResponseBodyList = Array<string>;
+export declare const ListOverTheBoxBackupsResponseBodyList: S.Schema<ListOverTheBoxBackupsResponseBodyList>;
+export type ListOverTheBoxBackupsResponse = ListOverTheBoxBackupsResponseBodyList;
+export declare const ListOverTheBoxBackupsResponse: S.Schema<ListOverTheBoxBackupsResponse>;
+export interface ListOverTheBoxDeviceActionsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Filter the value of name property (=) */
+    name?: string;
+    /** Filter the value of status property (=) */
+    status?: OverTheBoxActionStatusEnum | (string & {});
+}
+export declare const ListOverTheBoxDeviceActionsRequest: S.Schema<ListOverTheBoxDeviceActionsRequest>;
+export type ListOverTheBoxDeviceActionsResponseBodyList = Array<string>;
+export declare const ListOverTheBoxDeviceActionsResponseBodyList: S.Schema<ListOverTheBoxDeviceActionsResponseBodyList>;
+export type ListOverTheBoxDeviceActionsResponse = ListOverTheBoxDeviceActionsResponseBodyList;
+export declare const ListOverTheBoxDeviceActionsResponse: S.Schema<ListOverTheBoxDeviceActionsResponse>;
+export interface ListOverTheBoxDeviceAvailableActionsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const ListOverTheBoxDeviceAvailableActionsRequest: S.Schema<ListOverTheBoxDeviceAvailableActionsRequest>;
+/** Device action */
+export interface OverTheBoxAvailableDeviceAction {
+    /** Description of the action */
+    description?: string;
+    /** Name of the action */
+    name?: string;
+}
+export declare const OverTheBoxAvailableDeviceAction: S.Schema<OverTheBoxAvailableDeviceAction>;
+export type ListOverTheBoxDeviceAvailableActionsResponseBodyList = Array<OverTheBoxAvailableDeviceAction>;
+export declare const ListOverTheBoxDeviceAvailableActionsResponseBodyList: S.Schema<ListOverTheBoxDeviceAvailableActionsResponseBodyList>;
+export type ListOverTheBoxDeviceAvailableActionsResponse = ListOverTheBoxDeviceAvailableActionsResponseBodyList;
+export declare const ListOverTheBoxDeviceAvailableActionsResponse: S.Schema<ListOverTheBoxDeviceAvailableActionsResponse>;
+export type ListOverTheBoxHardwareRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListOverTheBoxHardwareRequestIamTagsValueList: S.Schema<ListOverTheBoxHardwareRequestIamTagsValueList>;
+export type ListOverTheBoxHardwareRequestIamTagsMap = {
+    [key: string]: ListOverTheBoxHardwareRequestIamTagsValueList | undefined;
+};
+export declare const ListOverTheBoxHardwareRequestIamTagsMap: S.Schema<ListOverTheBoxHardwareRequestIamTagsMap>;
+export interface ListOverTheBoxHardwareRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListOverTheBoxHardwareRequestIamTagsMap;
+}
+export declare const ListOverTheBoxHardwareRequest: S.Schema<ListOverTheBoxHardwareRequest>;
+export type ListOverTheBoxHardwareResponseBodyList = Array<string>;
+export declare const ListOverTheBoxHardwareResponseBodyList: S.Schema<ListOverTheBoxHardwareResponseBodyList>;
+export type ListOverTheBoxHardwareResponse = ListOverTheBoxHardwareResponseBodyList;
+export declare const ListOverTheBoxHardwareResponse: S.Schema<ListOverTheBoxHardwareResponse>;
+export interface ListOverTheBoxHardwareAvailableRequest {
+}
+export declare const ListOverTheBoxHardwareAvailableRequest: S.Schema<ListOverTheBoxHardwareAvailableRequest>;
+export type ListOverTheBoxHardwareAvailableResponseBodyList = Array<string>;
+export declare const ListOverTheBoxHardwareAvailableResponseBodyList: S.Schema<ListOverTheBoxHardwareAvailableResponseBodyList>;
+export type ListOverTheBoxHardwareAvailableResponse = ListOverTheBoxHardwareAvailableResponseBodyList;
+export declare const ListOverTheBoxHardwareAvailableResponse: S.Schema<ListOverTheBoxHardwareAvailableResponse>;
+export interface ListOverTheBoxIpsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const ListOverTheBoxIpsRequest: S.Schema<ListOverTheBoxIpsRequest>;
+export type ListOverTheBoxIpsResponseBodyList = Array<string>;
+export declare const ListOverTheBoxIpsResponseBodyList: S.Schema<ListOverTheBoxIpsResponseBodyList>;
+export type ListOverTheBoxIpsResponse = ListOverTheBoxIpsResponseBodyList;
+export declare const ListOverTheBoxIpsResponse: S.Schema<ListOverTheBoxIpsResponse>;
+export interface ListOverTheBoxMigrationOffersRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const ListOverTheBoxMigrationOffersRequest: S.Schema<ListOverTheBoxMigrationOffersRequest>;
+export type OrderCurrencyCodeEnum = "AUD" | "CAD" | "CZK" | "EUR" | "GBP" | "INR" | "LTL" | "MAD" | "N/A" | "PLN" | "SGD" | "TND" | "USD" | "XOF" | "points";
+export declare const OrderCurrencyCodeEnum: any;
+/** Price with it's currency and textual representation */
+export interface OrderPrice {
+    currencyCode?: OrderCurrencyCodeEnum;
+    text?: string;
+    value?: number;
+}
+export declare const OrderPrice: S.Schema<OrderPrice>;
+/** Details of available hardwares */
+export interface OverTheBoxHardwareDetails {
+    /** Pretty hardware model name */
+    hardwareDisplayName?: string | null;
+    /** Name of the hardware */
+    hardwareName?: string | null;
+    /** Hardware purchase price */
+    hardwarePrice?: OrderPrice | null;
+}
+export declare const OverTheBoxHardwareDetails: S.Schema<OverTheBoxHardwareDetails>;
+/** Details of available hardwares */
+export type OverTheBoxAvailableMigrationOfferHardwaresList = Array<OverTheBoxHardwareDetails>;
+export declare const OverTheBoxAvailableMigrationOfferHardwaresList: S.Schema<OverTheBoxAvailableMigrationOfferHardwaresList>;
+/** Migration offer */
+export interface OverTheBoxAvailableMigrationOffer {
+    /** Monthly price of the current offer */
+    currentOfferPrice?: OrderPrice;
+    /** Description of the offer */
+    description?: string;
+    /** Number of months of engagement */
+    engagementMonths?: number;
+    /** Specify if a hardware is available */
+    hardwareAvailable?: boolean;
+    /** Name of the hardware */
+    hardwareName?: string | null;
+    /** Hardware purchase price */
+    hardwarePrice?: OrderPrice | null;
+    /** Details of available hardwares */
+    hardwares?: OverTheBoxAvailableMigrationOfferHardwaresList;
+    /** Name of the offer */
+    offer?: string;
+    /** Monthly price of the new offer */
+    price?: OrderPrice;
+}
+export declare const OverTheBoxAvailableMigrationOffer: S.Schema<OverTheBoxAvailableMigrationOffer>;
+export type ListOverTheBoxMigrationOffersResponseBodyList = Array<OverTheBoxAvailableMigrationOffer>;
+export declare const ListOverTheBoxMigrationOffersResponseBodyList: S.Schema<ListOverTheBoxMigrationOffersResponseBodyList>;
+export type ListOverTheBoxMigrationOffersResponse = ListOverTheBoxMigrationOffersResponseBodyList;
+export declare const ListOverTheBoxMigrationOffersResponse: S.Schema<ListOverTheBoxMigrationOffersResponse>;
+export interface ListOverTheBoxRemoteAccessesRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+}
+export declare const ListOverTheBoxRemoteAccessesRequest: S.Schema<ListOverTheBoxRemoteAccessesRequest>;
+export type ListOverTheBoxRemoteAccessesResponseBodyList = Array<string>;
+export declare const ListOverTheBoxRemoteAccessesResponseBodyList: S.Schema<ListOverTheBoxRemoteAccessesResponseBodyList>;
+export type ListOverTheBoxRemoteAccessesResponse = ListOverTheBoxRemoteAccessesResponseBodyList;
+export declare const ListOverTheBoxRemoteAccessesResponse: S.Schema<ListOverTheBoxRemoteAccessesResponse>;
+/** Serie Name */
+export type OtbDeviceStatisticsTypeEnum = "load" | "memory_free" | "traffic";
+export declare const OtbDeviceStatisticsTypeEnum: any;
+/** Statistics Period */
+export type OtbDeviceStatisticsPeriodEnum = "daily" | "hourly" | "monthly" | "weekly";
+export declare const OtbDeviceStatisticsPeriodEnum: any;
+export interface ListOverTheBoxStatisticsRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Type of metrics you want to retrieve */
+    metricsType: OtbDeviceStatisticsTypeEnum | (string & {});
+    /** Period (default is daily) */
+    period?: OtbDeviceStatisticsPeriodEnum | (string & {});
+}
+export declare const ListOverTheBoxStatisticsRequest: S.Schema<ListOverTheBoxStatisticsRequest>;
+/** Statistics Datapoint */
+export interface OtbDeviceStatisticsPoint {
+    /** Timestamp */
+    timestamp?: number;
+    /** Datapoint value */
+    value?: number | null;
+}
+export declare const OtbDeviceStatisticsPoint: S.Schema<OtbDeviceStatisticsPoint>;
+/** List of point */
+export type OtbDeviceStatisticsPointsList = Array<OtbDeviceStatisticsPoint>;
+export declare const OtbDeviceStatisticsPointsList: S.Schema<OtbDeviceStatisticsPointsList>;
+/** Tags for the metrics */
+export interface OtbDeviceStatisticsTag {
+    /** Name of tag */
+    name?: string;
+    /** Value of tag */
+    value?: string | null;
+}
+export declare const OtbDeviceStatisticsTag: S.Schema<OtbDeviceStatisticsTag>;
+/** List of tags */
+export type OtbDeviceStatisticsTagsList = Array<OtbDeviceStatisticsTag>;
+export declare const OtbDeviceStatisticsTagsList: S.Schema<OtbDeviceStatisticsTagsList>;
+/** Serie Unit */
+export type OtbDeviceStatisticsUnitEnum = "bps" | "byte" | "n/a";
+export declare const OtbDeviceStatisticsUnitEnum: any;
+/** Device Statistics Datapoints */
+export interface OtbDeviceStatistics {
+    /** Name of the serie */
+    name?: string;
+    /** List of point */
+    points?: OtbDeviceStatisticsPointsList;
+    /** List of tags */
+    tags?: OtbDeviceStatisticsTagsList;
+    /** Unit of the serie */
+    unit?: OtbDeviceStatisticsUnitEnum;
+}
+export declare const OtbDeviceStatistics: S.Schema<OtbDeviceStatistics>;
+export type ListOverTheBoxStatisticsResponseBodyList = Array<OtbDeviceStatistics>;
+export declare const ListOverTheBoxStatisticsResponseBodyList: S.Schema<ListOverTheBoxStatisticsResponseBodyList>;
+export type ListOverTheBoxStatisticsResponse = ListOverTheBoxStatisticsResponseBodyList;
+export declare const ListOverTheBoxStatisticsResponse: S.Schema<ListOverTheBoxStatisticsResponse>;
+export interface ListOverTheBoxTasksRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Filter the value of name property (=) */
+    name?: string;
+    /** Filter the value of status property (=) */
+    status?: OverTheBoxTaskStatusEnum | (string & {});
+}
+export declare const ListOverTheBoxTasksRequest: S.Schema<ListOverTheBoxTasksRequest>;
+export type ListOverTheBoxTasksResponseBodyList = Array<string>;
+export declare const ListOverTheBoxTasksResponseBodyList: S.Schema<ListOverTheBoxTasksResponseBodyList>;
+export type ListOverTheBoxTasksResponse = ListOverTheBoxTasksResponseBodyList;
+export declare const ListOverTheBoxTasksResponse: S.Schema<ListOverTheBoxTasksResponse>;
+export interface PutOverTheBoxRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Enable device auto upgrade */
+    autoUpgrade?: boolean;
+    /** Editable field for customer */
+    customerDescription?: string | null;
+    /** Release channel of the service */
+    releaseChannel?: string;
+}
+export declare const PutOverTheBoxRequest: S.Schema<PutOverTheBoxRequest>;
+export interface PutOverTheBoxResponse {
+}
+export declare const PutOverTheBoxResponse: S.Schema<PutOverTheBoxResponse>;
+export interface PutOverTheBoxAutoMTURequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Enable or disable autoMTU */
+    mtuAuto: OverTheBoxAvailableStatusEnum | (string & {});
+}
+export declare const PutOverTheBoxAutoMTURequest: S.Schema<PutOverTheBoxAutoMTURequest>;
+export interface PutOverTheBoxAutoMTUResponse {
+}
+export declare const PutOverTheBoxAutoMTUResponse: S.Schema<PutOverTheBoxAutoMTUResponse>;
+export interface PutOverTheBoxIpv6Request {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Enabled/disabled IPv6 */
+    enabled: boolean;
+}
+export declare const PutOverTheBoxIpv6Request: S.Schema<PutOverTheBoxIpv6Request>;
+export interface PutOverTheBoxServiceInfosRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutOverTheBoxServiceInfosRequest: S.Schema<PutOverTheBoxServiceInfosRequest>;
+export interface PutOverTheBoxServiceInfosResponse {
+}
+export declare const PutOverTheBoxServiceInfosResponse: S.Schema<PutOverTheBoxServiceInfosResponse>;
+export interface RestoreOverTheBoxDeviceBackupRequest {
+    /** The internal name of your overTheBox offer */
+    serviceName: string;
+    /** The id of the backup to restore */
+    backupId: string;
+}
+export declare const RestoreOverTheBoxDeviceBackupRequest: S.Schema<RestoreOverTheBoxDeviceBackupRequest>;
+export type RestoreOverTheBoxDeviceBackupResponseBodyList = Array<OverTheBoxDeviceAction>;
+export declare const RestoreOverTheBoxDeviceBackupResponseBodyList: S.Schema<RestoreOverTheBoxDeviceBackupResponseBodyList>;
+export type RestoreOverTheBoxDeviceBackupResponse = RestoreOverTheBoxDeviceBackupResponseBodyList;
+export declare const RestoreOverTheBoxDeviceBackupResponse: S.Schema<RestoreOverTheBoxDeviceBackupResponse>;
+export type AuthorizeOverTheBoxRemoteAccessError = OvhOpError;
+/** Authorize the remote access */
+export declare const authorizeOverTheBoxRemoteAccess: API.OperationMethod<AuthorizeOverTheBoxRemoteAccessRequest, AuthorizeOverTheBoxRemoteAccessResponse, AuthorizeOverTheBoxRemoteAccessError, OvhOpContext>;
+export type CancelOverTheBoxResiliationError = OvhOpError;
+/** Cancel the resiliation of the Service */
+export declare const cancelOverTheBoxResiliation: API.OperationMethod<CancelOverTheBoxResiliationRequest, CancelOverTheBoxResiliationResponse, CancelOverTheBoxResiliationError, OvhOpContext>;
+export type CreateOverTheBoxChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createOverTheBoxChangeContact: API.OperationMethod<CreateOverTheBoxChangeContactRequest, CreateOverTheBoxChangeContactResponse, CreateOverTheBoxChangeContactError, OvhOpContext>;
+export type CreateOverTheBoxDeviceError = OvhOpError;
+/** Get the list of devices connected from the same IP address */
+export declare const createOverTheBoxDevice: API.OperationMethod<CreateOverTheBoxDeviceRequest, CreateOverTheBoxDeviceResponse, CreateOverTheBoxDeviceError, OvhOpContext>;
+export type CreateOverTheBoxDeviceActionError = OvhOpError;
+/** Create a device action on the device */
+export declare const createOverTheBoxDeviceAction: API.OperationMethod<CreateOverTheBoxDeviceActionRequest, OverTheBoxDeviceAction, CreateOverTheBoxDeviceActionError, OvhOpContext>;
+export type CreateOverTheBoxDeviceBackupError = OvhOpError;
+/** Create an action to generate a backup */
+export declare const createOverTheBoxDeviceBackup: API.OperationMethod<CreateOverTheBoxDeviceBackupRequest, OverTheBoxDeviceAction, CreateOverTheBoxDeviceBackupError, OvhOpContext>;
+export type CreateOverTheBoxDeviceLogError = OvhOpError;
+/** Generate a temporary url to retrieve device logs */
+export declare const createOverTheBoxDeviceLog: API.OperationMethod<CreateOverTheBoxDeviceLogRequest, OverTheBoxTemporaryLogsLink, CreateOverTheBoxDeviceLogError, OvhOpContext>;
+export type CreateOverTheBoxLinkDeviceError = OvhOpError;
+/** Link a device to this service */
+export declare const createOverTheBoxLinkDevice: API.OperationMethod<CreateOverTheBoxLinkDeviceRequest, CreateOverTheBoxLinkDeviceResponse, CreateOverTheBoxLinkDeviceError, OvhOpContext>;
+export type CreateOverTheBoxLinkHardwareError = OvhOpError;
+/** Link an available hardware to this service */
+export declare const createOverTheBoxLinkHardware: API.OperationMethod<CreateOverTheBoxLinkHardwareRequest, CreateOverTheBoxLinkHardwareResponse, CreateOverTheBoxLinkHardwareError, OvhOpContext>;
+export type CreateOverTheBoxMigrationChangeOfferError = OvhOpError;
+/** Migrate to the selected overTheBox offer */
+export declare const createOverTheBoxMigrationChangeOffer: API.OperationMethod<CreateOverTheBoxMigrationChangeOfferRequest, OverTheBoxOrderMigration, CreateOverTheBoxMigrationChangeOfferError, OvhOpContext>;
+export type CreateOverTheBoxRemoteAccessError = OvhOpError;
+/** Create a new remote access for the service */
+export declare const createOverTheBoxRemoteAccess: API.OperationMethod<CreateOverTheBoxRemoteAccessRequest, OverTheBoxRemoteAccess, CreateOverTheBoxRemoteAccessError, OvhOpContext>;
+export type DeleteOverTheBoxError = OvhOpError;
+/** Resiliate a service */
+export declare const deleteOverTheBox: API.OperationMethod<DeleteOverTheBoxRequest, DeleteOverTheBoxResponse, DeleteOverTheBoxError, OvhOpContext>;
+export type DeleteOverTheBoxBackupError = OvhOpError;
+/** Delete a backup */
+export declare const deleteOverTheBoxBackup: API.OperationMethod<DeleteOverTheBoxBackupRequest, DeleteOverTheBoxBackupResponse, DeleteOverTheBoxBackupError, OvhOpContext>;
+export type DeleteOverTheBoxDeviceError = OvhOpError;
+/** Unlink a device from a service */
+export declare const deleteOverTheBoxDevice: API.OperationMethod<DeleteOverTheBoxDeviceRequest, DeleteOverTheBoxDeviceResponse, DeleteOverTheBoxDeviceError, OvhOpContext>;
+export type DeleteOverTheBoxRemoteAccessError = OvhOpError;
+/** Delete a remote access */
+export declare const deleteOverTheBoxRemoteAccess: API.OperationMethod<DeleteOverTheBoxRemoteAccessRequest, DeleteOverTheBoxRemoteAccessResponse, DeleteOverTheBoxRemoteAccessError, OvhOpContext>;
+export type GetOverTheBoxError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBox: API.OperationMethod<GetOverTheBoxRequest, OverTheBoxServiceWithIAM, GetOverTheBoxError, OvhOpContext>;
+export type GetOverTheBoxBackupError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxBackup: API.OperationMethod<GetOverTheBoxBackupRequest, OverTheBoxBackup, GetOverTheBoxBackupError, OvhOpContext>;
+export type GetOverTheBoxDeviceError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxDevice: API.OperationMethod<GetOverTheBoxDeviceRequest, OverTheBoxDevice, GetOverTheBoxDeviceError, OvhOpContext>;
+export type GetOverTheBoxDeviceActionError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxDeviceAction: API.OperationMethod<GetOverTheBoxDeviceActionRequest, OverTheBoxDeviceAction, GetOverTheBoxDeviceActionError, OvhOpContext>;
+export type GetOverTheBoxDeviceHardwareError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxDeviceHardware: API.OperationMethod<GetOverTheBoxDeviceHardwareRequest, OverTheBoxHardware, GetOverTheBoxDeviceHardwareError, OvhOpContext>;
+export type GetOverTheBoxHardwareError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxHardware: API.OperationMethod<GetOverTheBoxHardwareRequest, OverTheBoxHardwareWithIAM, GetOverTheBoxHardwareError, OvhOpContext>;
+export type GetOverTheBoxIpsError = OvhOpError;
+/** Get details IP assigned to an OverTheBox service */
+export declare const getOverTheBoxIps: API.OperationMethod<GetOverTheBoxIpsRequest, OtbServiceIp, GetOverTheBoxIpsError, OvhOpContext>;
+export type GetOverTheBoxRemoteAccessError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxRemoteAccess: API.OperationMethod<GetOverTheBoxRemoteAccessRequest, OverTheBoxRemoteAccess, GetOverTheBoxRemoteAccessError, OvhOpContext>;
+export type GetOverTheBoxServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getOverTheBoxServiceInfos: API.OperationMethod<GetOverTheBoxServiceInfosRequest, ServicesService, GetOverTheBoxServiceInfosError, OvhOpContext>;
+export type GetOverTheBoxTaskError = OvhOpError;
+/** Get this object properties */
+export declare const getOverTheBoxTask: API.OperationMethod<GetOverTheBoxTaskRequest, OverTheBoxTask, GetOverTheBoxTaskError, OvhOpContext>;
+export type ListOverTheBoxError = OvhOpError;
+/** List available services */
+export declare const listOverTheBox: API.OperationMethod<ListOverTheBoxRequest, ListOverTheBoxResponse, ListOverTheBoxError, OvhOpContext>;
+export type ListOverTheBoxAvailableOffersError = OvhOpError;
+/** List the available offers for the new call */
+export declare const listOverTheBoxAvailableOffers: API.OperationMethod<ListOverTheBoxAvailableOffersRequest, ListOverTheBoxAvailableOffersResponse, ListOverTheBoxAvailableOffersError, OvhOpContext>;
+export type ListOverTheBoxAvailableReleaseChannelsError = OvhOpError;
+/** List available release channels for this service */
+export declare const listOverTheBoxAvailableReleaseChannels: API.OperationMethod<ListOverTheBoxAvailableReleaseChannelsRequest, ListOverTheBoxAvailableReleaseChannelsResponse, ListOverTheBoxAvailableReleaseChannelsError, OvhOpContext>;
+export type ListOverTheBoxBackupsError = OvhOpError;
+/** List of backups for this service */
+export declare const listOverTheBoxBackups: API.OperationMethod<ListOverTheBoxBackupsRequest, ListOverTheBoxBackupsResponse, ListOverTheBoxBackupsError, OvhOpContext>;
+export type ListOverTheBoxDeviceActionsError = OvhOpError;
+/** List of actions scheduled for this device */
+export declare const listOverTheBoxDeviceActions: API.OperationMethod<ListOverTheBoxDeviceActionsRequest, ListOverTheBoxDeviceActionsResponse, ListOverTheBoxDeviceActionsError, OvhOpContext>;
+export type ListOverTheBoxDeviceAvailableActionsError = OvhOpError;
+/** List the available device actions */
+export declare const listOverTheBoxDeviceAvailableActions: API.OperationMethod<ListOverTheBoxDeviceAvailableActionsRequest, ListOverTheBoxDeviceAvailableActionsResponse, ListOverTheBoxDeviceAvailableActionsError, OvhOpContext>;
+export type ListOverTheBoxHardwareError = OvhOpError;
+/** List available services */
+export declare const listOverTheBoxHardware: API.OperationMethod<ListOverTheBoxHardwareRequest, ListOverTheBoxHardwareResponse, ListOverTheBoxHardwareError, OvhOpContext>;
+export type ListOverTheBoxHardwareAvailableError = OvhOpError;
+/** List hardware that can be linked to a service */
+export declare const listOverTheBoxHardwareAvailable: API.OperationMethod<ListOverTheBoxHardwareAvailableRequest, ListOverTheBoxHardwareAvailableResponse, ListOverTheBoxHardwareAvailableError, OvhOpContext>;
+export type ListOverTheBoxIpsError = OvhOpError;
+/** List IP assigned to an OverTheBox service */
+export declare const listOverTheBoxIps: API.OperationMethod<ListOverTheBoxIpsRequest, ListOverTheBoxIpsResponse, ListOverTheBoxIpsError, OvhOpContext>;
+export type ListOverTheBoxMigrationOffersError = OvhOpError;
+/** List all available offers one can migrate to */
+export declare const listOverTheBoxMigrationOffers: API.OperationMethod<ListOverTheBoxMigrationOffersRequest, ListOverTheBoxMigrationOffersResponse, ListOverTheBoxMigrationOffersError, OvhOpContext>;
+export type ListOverTheBoxRemoteAccessesError = OvhOpError;
+/** List of remote accesses for the service */
+export declare const listOverTheBoxRemoteAccesses: API.OperationMethod<ListOverTheBoxRemoteAccessesRequest, ListOverTheBoxRemoteAccessesResponse, ListOverTheBoxRemoteAccessesError, OvhOpContext>;
+export type ListOverTheBoxStatisticsError = OvhOpError;
+/** Get statistics for an OTB device */
+export declare const listOverTheBoxStatistics: API.OperationMethod<ListOverTheBoxStatisticsRequest, ListOverTheBoxStatisticsResponse, ListOverTheBoxStatisticsError, OvhOpContext>;
+export type ListOverTheBoxTasksError = OvhOpError;
+/** List of tasks scheduled for this service */
+export declare const listOverTheBoxTasks: API.OperationMethod<ListOverTheBoxTasksRequest, ListOverTheBoxTasksResponse, ListOverTheBoxTasksError, OvhOpContext>;
+export type PutOverTheBoxError = OvhOpError;
+/** Alter this object properties */
+export declare const putOverTheBox: API.OperationMethod<PutOverTheBoxRequest, PutOverTheBoxResponse, PutOverTheBoxError, OvhOpContext>;
+export type PutOverTheBoxAutoMTUError = OvhOpError;
+/** Change the value of autoMTU */
+export declare const putOverTheBoxAutoMTU: API.OperationMethod<PutOverTheBoxAutoMTURequest, PutOverTheBoxAutoMTUResponse, PutOverTheBoxAutoMTUError, OvhOpContext>;
+export type PutOverTheBoxIpv6Error = OvhOpError;
+/** Change the status of IPv6 on this service */
+export declare const putOverTheBoxIpv6: API.OperationMethod<PutOverTheBoxIpv6Request, OverTheBoxTask, PutOverTheBoxIpv6Error, OvhOpContext>;
+export type PutOverTheBoxServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putOverTheBoxServiceInfos: API.OperationMethod<PutOverTheBoxServiceInfosRequest, PutOverTheBoxServiceInfosResponse, PutOverTheBoxServiceInfosError, OvhOpContext>;
+export type RestoreOverTheBoxDeviceBackupError = OvhOpError;
+/** Create a group of actions to restore a given backup */
+export declare const restoreOverTheBoxDeviceBackup: API.OperationMethod<RestoreOverTheBoxDeviceBackupRequest, RestoreOverTheBoxDeviceBackupResponse, RestoreOverTheBoxDeviceBackupError, OvhOpContext>;
+//# sourceMappingURL=overthebox.d.ts.map