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

package/lib/services/xdsl.d.ts

@@ -0,0 +1,3433 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type OvhOpError, type OvhOpContext } from "../protocol.ts";
+export type { OvhOpError, OvhOpContext };
+export interface AddDHCPStaticAddressRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+    /** IP address (e.g., 192.0.2.0) */
+    IPAddress: string;
+    /** The MAC address of the device */
+    MACAddress: string;
+    /** Name of the DHCP static lease */
+    name?: string;
+}
+export declare const AddDHCPStaticAddressRequest: S.Schema<AddDHCPStaticAddressRequest>;
+/** DHCP Static Address */
+export interface XdslDHCPStaticAddress {
+    /** IP address (e.g., 192.0.2.0) */
+    IPAddress?: string;
+    /** The MAC address of the device */
+    MACAddress?: string;
+    /** Name of the DHCP Static lease */
+    name?: string | null;
+    /** ID of the ongoing todo (NULL if none) */
+    taskId?: number | null;
+}
+export declare const XdslDHCPStaticAddress: S.Schema<XdslDHCPStaticAddress>;
+/** Frequency between notifications. */
+export type XdslMonitoringNotificationsFrequencyEnum = "1h" | "5m" | "6h" | "once";
+export declare const XdslMonitoringNotificationsFrequencyEnum: any;
+/** Type of notification. */
+export type XdslMonitoringNotificationsTypeEnum = "mail" | "sms";
+export declare const XdslMonitoringNotificationsTypeEnum: any;
+export interface AddMonitoringNotificationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Whether or not to allow notifications concerning generic incidents */
+    allowIncident?: boolean;
+    /** The number of seconds the access has to be down to trigger the alert */
+    downThreshold?: number;
+    /** The e-mail address, if type is mail */
+    email?: string;
+    /** Frequency between notifications. */
+    frequency: XdslMonitoringNotificationsFrequencyEnum | (string & {});
+    /** The phone number, if type is sms */
+    phone?: string;
+    /** The SMS account which will be debited for each sent SMS, if the type is sms */
+    smsAccount?: string;
+    /** Type of notification. */
+    type: XdslMonitoringNotificationsTypeEnum | (string & {});
+}
+export declare const AddMonitoringNotificationRequest: S.Schema<AddMonitoringNotificationRequest>;
+/** Defines where and how the notifications will be sent */
+export interface XdslMonitoringNotification {
+    /** Whether or not to allow notifications for generic incidents */
+    allowIncident?: boolean;
+    /** The number of seconds the access has to be down to trigger an alert */
+    downThreshold?: number;
+    /** The e-mail address, if type is mail */
+    email?: string | null;
+    /** Whether to enable or not */
+    enabled?: boolean;
+    /** Frequency between notifications. */
+    frequency?: XdslMonitoringNotificationsFrequencyEnum;
+    id?: number;
+    /** The phone number, if type is sms */
+    phone?: string | null;
+    /** The SMS account which will be debited for each sent SMS, if the type is sms */
+    smsAccount?: string | null;
+    type?: XdslMonitoringNotificationsTypeEnum;
+}
+export declare const XdslMonitoringNotification: S.Schema<XdslMonitoringNotification>;
+/** Type of protocol for the Port Mapping */
+export type XdslXdslModemConfigProtocolTypeEnum = "TCP" | "UDP";
+export declare const XdslXdslModemConfigProtocolTypeEnum: any;
+export interface AddPortMappingRequest {
+    /** Service name */
+    serviceName: string;
+    /** IPv4 address (e.g., 192.0.2.0) */
+    allowedRemoteIp?: string;
+    /** Description of the Port Mapping */
+    description?: string;
+    /** The last port of the interval on the External Client that will get the connections */
+    externalPortEnd?: number;
+    /** External Port that the modem will listen on */
+    externalPortStart: number;
+    /** IP address (e.g., 192.0.2.0) */
+    internalClient: string;
+    /** The port on the Internal Client that will get the connections */
+    internalPort: number;
+    /** The last port of the interval on the Internal Client that will get the connections */
+    internalPortEnd?: number;
+    /** Name of the port mapping entry */
+    name: string;
+    /** Type of protocol for the Port Mapping */
+    protocol: XdslXdslModemConfigProtocolTypeEnum | (string & {});
+}
+export declare const AddPortMappingRequest: S.Schema<AddPortMappingRequest>;
+/** Port Mappings */
+export interface XdslPortMapping {
+    /** An ip which will access to the defined rule. Default : no restriction applied */
+    allowedRemoteIp?: string | null;
+    /** Description of the Port Mapping */
+    description?: string | null;
+    /** The last port of the interval on the External Client that will get the connections */
+    externalPortEnd?: number | null;
+    /** External Port that the modem will listen on. List of externalPorts not available for now in the API : 8, 21, 68, 5060, 21800-21805, 51005 */
+    externalPortStart?: number;
+    /** ID of the port mapping entry */
+    id?: number;
+    /** IP address (e.g., 192.0.2.0) */
+    internalClient?: string;
+    /** The port on the Internal Client that will get the connections */
+    internalPort?: number;
+    /** The last port of the interval on the Internal Client that will get the connections */
+    internalPortEnd?: number | null;
+    /** Name of the port mapping entry */
+    name?: string;
+    /** Type of protocol for the Port Mapping */
+    protocol?: XdslXdslModemConfigProtocolTypeEnum;
+    /** ID of the ongoing todo (NULL if none) */
+    taskId?: number | null;
+}
+export declare const XdslPortMapping: S.Schema<XdslPortMapping>;
+export interface ApplyTemplateModemRequest {
+    /** Service name */
+    serviceName: string;
+    /** Modem Template Name */
+    templateName: string;
+}
+export declare const ApplyTemplateModemRequest: S.Schema<ApplyTemplateModemRequest>;
+/** Status of a task. */
+export type XdslTaskStatusEnum = "cancelled" | "doing" | "done" | "error" | "problem" | "todo";
+export declare const XdslTaskStatusEnum: any;
+/** Describes the current status of a task */
+export interface XdslTask {
+    function?: string;
+    id?: number;
+    status?: XdslTaskStatusEnum;
+    /** Date when the action will start */
+    todoDate?: string;
+    updateDate?: string;
+}
+export declare const XdslTask: S.Schema<XdslTask>;
+export interface ArchiveXdslTaskRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const ArchiveXdslTaskRequest: S.Schema<ArchiveXdslTaskRequest>;
+export interface ArchiveXdslTaskResponse {
+}
+export declare const ArchiveXdslTaskResponse: S.Schema<ArchiveXdslTaskResponse>;
+export interface BookMeetingRequest {
+    /** Service name */
+    serviceName: string;
+    /** Meeting end date */
+    endDate: string;
+    /** Meeting start date */
+    startDate: string;
+    /** Meeting ui code ( code linked to the meeting returned by POST /xdsl/{serviceName}/orderMeetings ) */
+    uiCode: string;
+}
+export declare const BookMeetingRequest: S.Schema<BookMeetingRequest>;
+export interface BookMeetingResponse {
+}
+export declare const BookMeetingResponse: S.Schema<BookMeetingResponse>;
+export interface CancelXdslLinesDiagnosticRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+}
+export declare const CancelXdslLinesDiagnosticRequest: S.Schema<CancelXdslLinesDiagnosticRequest>;
+export interface CancelXdslLinesDiagnosticResponse {
+}
+export declare const CancelXdslLinesDiagnosticResponse: S.Schema<CancelXdslLinesDiagnosticResponse>;
+export interface CancelXdslResiliationRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CancelXdslResiliationRequest: S.Schema<CancelXdslResiliationRequest>;
+export interface CancelXdslResiliationResponse {
+}
+export declare const CancelXdslResiliationResponse: S.Schema<CancelXdslResiliationResponse>;
+export interface ChangeContactRequest {
+    /** Service name */
+    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 ChangeContactRequest: S.Schema<ChangeContactRequest>;
+export type ChangeContactResponseBodyList = Array<number>;
+export declare const ChangeContactResponseBodyList: S.Schema<ChangeContactResponseBodyList>;
+export type ChangeContactResponse = ChangeContactResponseBodyList;
+export declare const ChangeContactResponse: S.Schema<ChangeContactResponse>;
+export interface ChangeEmailPasswordRequest {
+    /** Email */
+    email: string;
+    /** New email password */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const ChangeEmailPasswordRequest: S.Schema<ChangeEmailPasswordRequest>;
+/** Status of an Email Pro task. */
+export type XdslEmailProTaskStatusEnum = "cancelled" | "doing" | "done" | "error" | "todo";
+export declare const XdslEmailProTaskStatusEnum: any;
+/** Task Struct */
+export interface XdslEmailProTask {
+    /** Finished date of the task */
+    finishDate?: string | null;
+    /** Function of the task */
+    function?: string;
+    /** Status of an Email Pro task. */
+    status?: XdslEmailProTaskStatusEnum;
+    /** Todo date of the task */
+    todoDate?: string;
+}
+export declare const XdslEmailProTask: S.Schema<XdslEmailProTask>;
+export interface ChangeLineDSLAMProfileRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+    /** The id of the xdsl.DslamLineProfile */
+    dslamProfileId: number;
+}
+export declare const ChangeLineDSLAMProfileRequest: S.Schema<ChangeLineDSLAMProfileRequest>;
+export interface CreateModemTemplateRequest {
+    /** Modem Template name (only alphanumeric characters) */
+    name: string;
+    /** The access name with the config you want to duplicate */
+    serviceName: string;
+}
+export declare const CreateModemTemplateRequest: S.Schema<CreateModemTemplateRequest>;
+/** DHCP Configuration for Modem Template */
+export interface XdslTemplateModemDHCP {
+    /** IP address (e.g., 192.0.2.0) */
+    defaultGateway?: string;
+    /** Name of the DHCP */
+    dhcpName?: string;
+    /** Domain name provided to the clients */
+    domainName?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    endAddress?: string;
+    /** Lease time in seconds of client assigned address (-1 means infinite) */
+    leaseTime?: number;
+    /** IP address (e.g., 192.0.2.0) */
+    primaryDNS?: string;
+    /** Secondary DNS servers to be given to the clients */
+    secondaryDNS?: string | null;
+    /** State of the DHCP server of the modem */
+    serverEnabled?: boolean;
+    /** IP address (e.g., 192.0.2.0) */
+    startAddress?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    subnetMask?: string;
+}
+export declare const XdslTemplateModemDHCP: S.Schema<XdslTemplateModemDHCP>;
+/** List of DHCP for this template */
+export type XdslTemplateModemDHCPList = Array<XdslTemplateModemDHCP>;
+export declare const XdslTemplateModemDHCPList: S.Schema<XdslTemplateModemDHCPList>;
+/** How the modem gets its LAN IP Address */
+export type XdslXdslModemConfigAddressingTypeEnum = "DHCP" | "Static";
+export declare const XdslXdslModemConfigAddressingTypeEnum: any;
+/** LAN Configuration for Modem Template */
+export interface XdslTemplateModemLAN {
+    /** IP address (e.g., 192.0.2.0) */
+    IPAddress?: string;
+    /** How the modem gets its LAN IP Address */
+    addressingType?: XdslXdslModemConfigAddressingTypeEnum;
+    /** Name of the LAN */
+    lanName?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    subnetMask?: string;
+}
+export declare const XdslTemplateModemLAN: S.Schema<XdslTemplateModemLAN>;
+/** List of LAN for this template */
+export type XdslTemplateModemLANList = Array<XdslTemplateModemLAN>;
+export declare const XdslTemplateModemLANList: S.Schema<XdslTemplateModemLANList>;
+/** How the WiFi channel is selected */
+export type XdslXdslModemConfigChannelModeEnum = "Auto" | "Manual";
+export declare const XdslXdslModemConfigChannelModeEnum: any;
+/** Modem frequency */
+export type XdslXdslModemConfigFrequencyEnum = "2.4GHz" | "5GHz";
+export declare const XdslXdslModemConfigFrequencyEnum: any;
+/** Type of WLAN security protection */
+export type XdslTemplateModemSecurityTypeEnum = "None" | "WPA" | "WPA2" | "WPA2andWPA3" | "WPA3" | "WPAandWPA2";
+export declare const XdslTemplateModemSecurityTypeEnum: any;
+/** WLAN Configuration for Modem Template */
+export interface XdslTemplateModemWLAN {
+    /** Service Set Identifier of the WLAN interface */
+    SSID?: string;
+    /** Control if Wifi is discoverable or hidden */
+    SSIDAdvertisementEnabled?: boolean;
+    /** Indicate if frequencies 2.4GHz and 5GHz are agregated */
+    bandSteering?: boolean;
+    /** Channel number (Useless if channelMode is set to Auto) */
+    channel?: number;
+    /** How the WiFi channel is selected */
+    channelMode?: XdslXdslModemConfigChannelModeEnum;
+    /** Wifi state */
+    enabled?: boolean;
+    /** Modem frequency */
+    frequency?: XdslXdslModemConfigFrequencyEnum;
+    /** Indicate if it is normal access wifi or guest wifi */
+    guest?: boolean;
+    /** Encrypted WLAN passphrase */
+    securityKey?: string;
+    /** Type of WLAN security protection */
+    securityType?: XdslTemplateModemSecurityTypeEnum;
+    /** Wifi Name */
+    wifiName?: string;
+}
+export declare const XdslTemplateModemWLAN: S.Schema<XdslTemplateModemWLAN>;
+/** List of WLAN for this template */
+export type XdslTemplateModemWLANList = Array<XdslTemplateModemWLAN>;
+export declare const XdslTemplateModemWLANList: S.Schema<XdslTemplateModemWLANList>;
+/** Size of the Maximum Transmission Unit on the modem's interfaces */
+export type XdslXdslModemConfigMTUSizeEnum = 1432 | 1456 | 1492;
+export declare const XdslXdslModemConfigMTUSizeEnum: any;
+/** WLAN names list to ignore. Ignore only listed WLAN */
+export type XdslTemplateModemParametersToIgnoreWLANListList = Array<string>;
+export declare const XdslTemplateModemParametersToIgnoreWLANListList: S.Schema<XdslTemplateModemParametersToIgnoreWLANListList>;
+/** PortMapping names list to ignore. Ignore only listed portMapping */
+export type XdslTemplateModemParametersToIgnorePortMappingListList = Array<string>;
+export declare const XdslTemplateModemParametersToIgnorePortMappingListList: S.Schema<XdslTemplateModemParametersToIgnorePortMappingListList>;
+/** Parameters and values to ignore when apply modem template configuration */
+export interface XdslTemplateModemParametersToIgnore {
+    /** Ignore LAN and DHCP configurations */
+    LANandDHCP?: boolean | null;
+    /** WLAN names list to ignore. Ignore only listed WLAN */
+    WLANList?: XdslTemplateModemParametersToIgnoreWLANListList | null;
+    /** Ignore DMZ configuration */
+    dmzIP?: boolean | null;
+    /** Ignore MTU Size value */
+    mtuSize?: boolean | null;
+    /** PortMapping names list to ignore. Ignore only listed portMapping */
+    portMappingList?: XdslTemplateModemParametersToIgnorePortMappingListList | null;
+}
+export declare const XdslTemplateModemParametersToIgnore: S.Schema<XdslTemplateModemParametersToIgnore>;
+/** PortMapping Configuration for Modem Template */
+export interface XdslTemplateModemPortMapping {
+    /** An ip which will access to the defined rule. Default : no restriction applied */
+    allowedRemoteIp?: string | null;
+    /** Description of the Port Mapping */
+    description?: string | null;
+    /** The last port of the interval on the External Client that will get the connections */
+    externalPortEnd?: number | null;
+    /** External Port that the modem will listen on. List of externalPorts not available for now in the API : 8, 21, 68, 5060, 21800-21805, 51005 */
+    externalPortStart?: number;
+    /** IP address (e.g., 192.0.2.0) */
+    internalClient?: string;
+    /** The port on the Internal Client that will get the connections */
+    internalPort?: number;
+    /** Name of the port mapping entry */
+    name?: string;
+    /** Type of protocol for the Port Mapping */
+    protocol?: XdslXdslModemConfigProtocolTypeEnum;
+}
+export declare const XdslTemplateModemPortMapping: S.Schema<XdslTemplateModemPortMapping>;
+/** List of PortMapping for this template */
+export type XdslTemplateModemPortMappingList = Array<XdslTemplateModemPortMapping>;
+export declare const XdslTemplateModemPortMappingList: S.Schema<XdslTemplateModemPortMappingList>;
+/** Modem Template */
+export interface XdslTemplateModem {
+    /** List of DHCP for this template */
+    DHCP?: XdslTemplateModemDHCPList;
+    /** List of LAN for this template */
+    LAN?: XdslTemplateModemLANList;
+    /** List of WLAN for this template */
+    WLAN?: XdslTemplateModemWLANList;
+    /** Parameters capabilities. Lists what can be applied from this template */
+    capabilities?: string;
+    /** Template creation date */
+    creationDate?: string;
+    /** IP Address of the DMZ */
+    dmzIP?: string | null;
+    /** Size of the Maximum Transmission Unit on the modem's interfaces */
+    mtuSize?: XdslXdslModemConfigMTUSizeEnum | null;
+    /** Name of the Modem Template */
+    name?: string;
+    /** Do not apply these parameters from template. You can use parametersCapabilities to know availability */
+    parametersToIgnore?: XdslTemplateModemParametersToIgnore | null;
+    /** List of PortMapping for this template */
+    portMapping?: XdslTemplateModemPortMappingList;
+}
+export declare const XdslTemplateModem: S.Schema<XdslTemplateModem>;
+export interface CreateXdslAddressMoveExtraIpRangeMoveRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateXdslAddressMoveExtraIpRangeMoveRequest: S.Schema<CreateXdslAddressMoveExtraIpRangeMoveRequest>;
+export interface CreateXdslDiagnosticRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateXdslDiagnosticRequest: S.Schema<CreateXdslDiagnosticRequest>;
+export interface CreateXdslIpsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateXdslIpsRequest: S.Schema<CreateXdslIpsRequest>;
+export interface CreateXdslModemReconfigureVoipRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateXdslModemReconfigureVoipRequest: S.Schema<CreateXdslModemReconfigureVoipRequest>;
+export interface CreateXdslModemReconfigureVoipResponse {
+}
+export declare const CreateXdslModemReconfigureVoipResponse: S.Schema<CreateXdslModemReconfigureVoipResponse>;
+export interface CreateXdslRequestPPPLoginMailRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateXdslRequestPPPLoginMailRequest: S.Schema<CreateXdslRequestPPPLoginMailRequest>;
+export interface CreateXdslRequestPPPLoginMailResponse {
+}
+export declare const CreateXdslRequestPPPLoginMailResponse: S.Schema<CreateXdslRequestPPPLoginMailResponse>;
+export interface CreateXdslSpareReturnMerchandiseRequest {
+    /** Spare */
+    spare: string;
+}
+export declare const CreateXdslSpareReturnMerchandiseRequest: S.Schema<CreateXdslSpareReturnMerchandiseRequest>;
+export interface CreateXdslSpareReturnMerchandiseResponse {
+}
+export declare const CreateXdslSpareReturnMerchandiseResponse: S.Schema<CreateXdslSpareReturnMerchandiseResponse>;
+export interface DeleteModemTemplateRequest {
+    /** Name */
+    name: string;
+}
+export declare const DeleteModemTemplateRequest: S.Schema<DeleteModemTemplateRequest>;
+export interface DeleteModemTemplateResponse {
+}
+export declare const DeleteModemTemplateResponse: S.Schema<DeleteModemTemplateResponse>;
+export interface DeleteXdslEmailProRequest {
+    /** Email */
+    email: string;
+}
+export declare const DeleteXdslEmailProRequest: S.Schema<DeleteXdslEmailProRequest>;
+export interface DeleteXdslEmailProResponse {
+}
+export declare const DeleteXdslEmailProResponse: S.Schema<DeleteXdslEmailProResponse>;
+export interface DeleteXdslIpsRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const DeleteXdslIpsRequest: S.Schema<DeleteXdslIpsRequest>;
+export interface DeleteXdslIpsResponse {
+}
+export declare const DeleteXdslIpsResponse: S.Schema<DeleteXdslIpsResponse>;
+export interface DeleteXdslRmaRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: string;
+}
+export declare const DeleteXdslRmaRequest: S.Schema<DeleteXdslRmaRequest>;
+export interface DeleteXdslRmaResponse {
+}
+export declare const DeleteXdslRmaResponse: S.Schema<DeleteXdslRmaResponse>;
+export interface DeleteXdslSpareRequest {
+    /** Spare */
+    spare: string;
+}
+export declare const DeleteXdslSpareRequest: S.Schema<DeleteXdslSpareRequest>;
+export interface DeleteXdslSpareResponse {
+}
+export declare const DeleteXdslSpareResponse: S.Schema<DeleteXdslSpareResponse>;
+export interface GetAccessModemReplacementRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetAccessModemReplacementRequest: S.Schema<GetAccessModemReplacementRequest>;
+/** Currency code */
+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 its currency and textual representation */
+export interface OrderPrice {
+    /** Currency code */
+    currencyCode?: OrderCurrencyCodeEnum;
+    /** Price in microcents */
+    priceInUcents?: number | null;
+    /** Textual representation */
+    text?: string;
+    /** The effective price */
+    value?: number;
+}
+export declare const OrderPrice: S.Schema<OrderPrice>;
+/** Information about modem exchange */
+export interface XdslModemExchangeInfo {
+    /** To know if you can exchange your modem */
+    canExchange?: boolean;
+    /** Model of the new modem */
+    newModel?: string;
+    /** Price with it's currency and textual representation */
+    price?: OrderPrice;
+    /** Price with it's currency and textual representation */
+    priceWithTax?: OrderPrice;
+}
+export declare const XdslModemExchangeInfo: S.Schema<XdslModemExchangeInfo>;
+export interface GetBlocIPStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetBlocIPStatusRequest: S.Schema<GetBlocIPStatusRequest>;
+/** Status of the service */
+export type XdslServiceStatusEnum = "disabled" | "enabled";
+export declare const XdslServiceStatusEnum: any;
+export type GetBlocIPStatusResponse = XdslServiceStatusEnum;
+export declare const GetBlocIPStatusResponse: S.Schema<GetBlocIPStatusResponse>;
+export interface GetContentSharingStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetContentSharingStatusRequest: S.Schema<GetContentSharingStatusRequest>;
+export type GetContentSharingStatusResponse = XdslServiceStatusEnum;
+export declare const GetContentSharingStatusResponse: S.Schema<GetContentSharingStatusResponse>;
+export interface GetDHCPStaticAddressRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+    /** macaddress */
+    MACAddress: string;
+}
+export declare const GetDHCPStaticAddressRequest: S.Schema<GetDHCPStaticAddressRequest>;
+export interface GetDHCPStaticAddressesRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+}
+export declare const GetDHCPStaticAddressesRequest: S.Schema<GetDHCPStaticAddressesRequest>;
+export type GetDHCPStaticAddressesResponseBodyList = Array<string>;
+export declare const GetDHCPStaticAddressesResponseBodyList: S.Schema<GetDHCPStaticAddressesResponseBodyList>;
+export type GetDHCPStaticAddressesResponse = GetDHCPStaticAddressesResponseBodyList;
+export declare const GetDHCPStaticAddressesResponse: S.Schema<GetDHCPStaticAddressesResponse>;
+export interface GetFirmwareVersionRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetFirmwareVersionRequest: S.Schema<GetFirmwareVersionRequest>;
+export type GetFirmwareVersionResponse = string;
+export declare const GetFirmwareVersionResponse: S.Schema<GetFirmwareVersionResponse>;
+export interface GetFTPStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetFTPStatusRequest: S.Schema<GetFTPStatusRequest>;
+export type GetFTPStatusResponse = XdslServiceStatusEnum;
+export declare const GetFTPStatusResponse: S.Schema<GetFTPStatusResponse>;
+export interface GetIpsecAlgStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetIpsecAlgStatusRequest: S.Schema<GetIpsecAlgStatusRequest>;
+export type GetIpsecAlgStatusResponse = XdslServiceStatusEnum;
+export declare const GetIpsecAlgStatusResponse: S.Schema<GetIpsecAlgStatusResponse>;
+export interface GetModemCallWaitingStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetModemCallWaitingStatusRequest: S.Schema<GetModemCallWaitingStatusRequest>;
+export type GetModemCallWaitingStatusResponse = XdslServiceStatusEnum;
+export declare const GetModemCallWaitingStatusResponse: S.Schema<GetModemCallWaitingStatusResponse>;
+export interface GetModemTemplateRequest {
+    /** Name */
+    name: string;
+}
+export declare const GetModemTemplateRequest: S.Schema<GetModemTemplateRequest>;
+export interface GetModemTemplatesRequest {
+}
+export declare const GetModemTemplatesRequest: S.Schema<GetModemTemplatesRequest>;
+export type GetModemTemplatesResponseBodyList = Array<string>;
+export declare const GetModemTemplatesResponseBodyList: S.Schema<GetModemTemplatesResponseBodyList>;
+export type GetModemTemplatesResponse = GetModemTemplatesResponseBodyList;
+export declare const GetModemTemplatesResponse: S.Schema<GetModemTemplatesResponse>;
+export interface GetMonitoringNotificationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetMonitoringNotificationRequest: S.Schema<GetMonitoringNotificationRequest>;
+export interface GetMonitoringNotificationsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetMonitoringNotificationsRequest: S.Schema<GetMonitoringNotificationsRequest>;
+export type GetMonitoringNotificationsResponseBodyList = Array<number>;
+export declare const GetMonitoringNotificationsResponseBodyList: S.Schema<GetMonitoringNotificationsResponseBodyList>;
+export type GetMonitoringNotificationsResponse = GetMonitoringNotificationsResponseBodyList;
+export declare const GetMonitoringNotificationsResponse: S.Schema<GetMonitoringNotificationsResponse>;
+export interface GetPortMappingRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name */
+    name: string;
+}
+export declare const GetPortMappingRequest: S.Schema<GetPortMappingRequest>;
+export interface GetPortMappingsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetPortMappingsRequest: S.Schema<GetPortMappingsRequest>;
+export type GetPortMappingsResponseBodyList = Array<string>;
+export declare const GetPortMappingsResponseBodyList: S.Schema<GetPortMappingsResponseBodyList>;
+export type GetPortMappingsResponse = GetPortMappingsResponseBodyList;
+export declare const GetPortMappingsResponse: S.Schema<GetPortMappingsResponse>;
+export interface GetSipAlgStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetSipAlgStatusRequest: S.Schema<GetSipAlgStatusRequest>;
+export type GetSipAlgStatusResponse = XdslServiceStatusEnum;
+export declare const GetSipAlgStatusResponse: S.Schema<GetSipAlgStatusResponse>;
+export interface GetUpnpStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetUpnpStatusRequest: S.Schema<GetUpnpStatusRequest>;
+export type GetUpnpStatusResponse = XdslServiceStatusEnum;
+export declare const GetUpnpStatusResponse: S.Schema<GetUpnpStatusResponse>;
+export interface GetWifiMeshStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetWifiMeshStatusRequest: S.Schema<GetWifiMeshStatusRequest>;
+export type GetWifiMeshStatusResponse = XdslServiceStatusEnum;
+export declare const GetWifiMeshStatusResponse: S.Schema<GetWifiMeshStatusResponse>;
+export interface GetWifiOneSsidStatusRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetWifiOneSsidStatusRequest: S.Schema<GetWifiOneSsidStatusRequest>;
+export type GetWifiOneSsidStatusResponse = XdslServiceStatusEnum;
+export declare const GetWifiOneSsidStatusResponse: S.Schema<GetWifiOneSsidStatusResponse>;
+export interface GetXdslRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslRequest: S.Schema<GetXdslRequest>;
+/** Possible DSL technologies */
+export type XdslDslTypeEnum = "adsl" | "ftte" | "ftth" | "sdsl" | "vdsl";
+export declare const XdslDslTypeEnum: any;
+/** All components of an address */
+export interface XdslAddressDetail {
+    building?: string | null;
+    city?: string;
+    door?: string | null;
+    firstName?: string;
+    floor?: string | null;
+    /** Identifier of the city */
+    inseeCode?: string;
+    lastName?: string;
+    numberStreet?: string;
+    residence?: string | null;
+    /** Identifier of the street */
+    rivoliCode?: string;
+    stairs?: string | null;
+    street?: string;
+    zipCode?: string;
+}
+export declare const XdslAddressDetail: S.Schema<XdslAddressDetail>;
+/** Describe the capabilities of the Access */
+export interface XdslAccessCapabilities {
+    canApplyLnsRateLimit?: boolean;
+    canChangeDslamProfile?: boolean;
+    canChangeLns?: boolean;
+    canGetRadiusConnectionLogs?: boolean;
+    canResetDslamPort?: boolean;
+    hasDslamPort?: boolean;
+}
+export declare const XdslAccessCapabilities: S.Schema<XdslAccessCapabilities>;
+/** 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 allowed for mail sending */
+export type XdslMailSendingAccessStatusEnum = "blockedForSpam" | "disabled" | "enabled";
+export declare const XdslMailSendingAccessStatusEnum: any;
+/** The providers */
+export type XdslProviderEnum = "axione" | "bouygues" | "ft" | "ftBySfr" | "kosc" | "koscDeg" | "ovh" | "sfr";
+export declare const XdslProviderEnum: any;
+/** Available access roles */
+export type XdslAccessRoleEnum = "backup" | "main";
+export declare const XdslAccessRoleEnum: any;
+/** Status of the access */
+export type XdslAccessStatusEnum = "active" | "cancelled" | "close" | "deleting" | "doing" | "migration" | "slamming" | "terminated" | "upgradeOffer";
+export declare const XdslAccessStatusEnum: any;
+/** XDSL Access */
+export interface XdslAccessWithIAM {
+    accessName?: string;
+    accessType?: XdslDslTypeEnum;
+    address?: XdslAddressDetail;
+    capabilities?: XdslAccessCapabilities;
+    description?: string;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    ipv6Enabled?: boolean;
+    /** Rate limit on the LNS in kbps - Only available if canApplyLnsRateLimit capability is set to true - Must be a multiple of 64 - Min value 64 / Max value 100032 */
+    lnsRateLimit?: number | null;
+    /** Status of mail sending on the Access */
+    mailSending?: XdslMailSendingAccessStatusEnum | null;
+    /** Whether or not this access is monitored */
+    monitoring?: boolean;
+    nra?: string;
+    /** Pack name, if access is in a pack */
+    packName?: string | null;
+    pairsNumber?: number;
+    /** The provider */
+    provider?: XdslProviderEnum;
+    /** The provider of the infrastructure, if applicable */
+    providerInfra?: string | null;
+    role?: XdslAccessRoleEnum;
+    status?: XdslAccessStatusEnum;
+}
+export declare const XdslAccessWithIAM: S.Schema<XdslAccessWithIAM>;
+export interface GetXdslAddressMoveExtraIpRangeRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslAddressMoveExtraIpRangeRequest: S.Schema<GetXdslAddressMoveExtraIpRangeRequest>;
+/** Informations about the extra IP range during address move */
+export interface XdslExtraIpRangeMove {
+    /** Date of the migration */
+    date?: string;
+    /** IPv4 CIDR notation (e.g., 192.0.2.0/24) */
+    ipRange?: string;
+    /** Access where the IP range will be moved to */
+    moveTo?: string;
+}
+export declare const XdslExtraIpRangeMove: S.Schema<XdslExtraIpRangeMove>;
+export interface GetXdslAntiSpamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const GetXdslAntiSpamRequest: S.Schema<GetXdslAntiSpamRequest>;
+/** AntiSpam status */
+export type XdslAntiSpamAntiSpamStatusEnum = "block" | "done" | "new" | "unblock" | "warn";
+export declare const XdslAntiSpamAntiSpamStatusEnum: any;
+/** Spams detected from xdsl access */
+export interface XdslAntiSpam {
+    /** Detection date */
+    date?: string;
+    /** IP which spam */
+    ip?: string;
+    /** Last spam detection date */
+    lastSpamDetected?: string;
+    /** AntiSpam status */
+    status?: XdslAntiSpamAntiSpamStatusEnum;
+}
+export declare const XdslAntiSpam: S.Schema<XdslAntiSpam>;
+export interface GetXdslCanCancelResiliationRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslCanCancelResiliationRequest: S.Schema<GetXdslCanCancelResiliationRequest>;
+export type GetXdslCanCancelResiliationResponse = boolean;
+export declare const GetXdslCanCancelResiliationResponse: S.Schema<GetXdslCanCancelResiliationResponse>;
+export interface GetXdslDiagnosticRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslDiagnosticRequest: S.Schema<GetXdslDiagnosticRequest>;
+/** Describe the capabilities of the access diagnostic */
+export interface XdslAccessDiagnosticCapabilities {
+    incident?: boolean;
+    isActiveOnLns?: boolean;
+    isModemConnected?: boolean;
+    lineTest?: boolean;
+    ping?: boolean;
+    proposedProfileId?: boolean;
+    sync?: boolean;
+}
+export declare const XdslAccessDiagnosticCapabilities: S.Schema<XdslAccessDiagnosticCapabilities>;
+/** Line tests results */
+export type XdslLineTestEnum = "actionPending" | "customerSideProblem" | "error" | "noProblem" | "ovhSideProblem";
+export declare const XdslLineTestEnum: any;
+/** Detailed line tests */
+export interface XdslLineDiagnostic {
+    lineTest?: XdslLineTestEnum | null;
+    lineTestTime?: string | null;
+    number?: string;
+    proposedProfileId?: number | null;
+    sync?: boolean;
+}
+export declare const XdslLineDiagnostic: S.Schema<XdslLineDiagnostic>;
+/** Test details by line */
+export type XdslAccessDiagnosticLineDetailsList = Array<XdslLineDiagnostic>;
+export declare const XdslAccessDiagnosticLineDetailsList: S.Schema<XdslAccessDiagnosticLineDetailsList>;
+/** Diagnostic of the access */
+export interface XdslAccessDiagnostic {
+    /** Available tests for this access */
+    capabilities?: XdslAccessDiagnosticCapabilities;
+    /** Datime of the diagnostic */
+    diagnosticTime?: string;
+    /** Is there an ongoing genericIncident on the access ? */
+    incident?: boolean | null;
+    /** Is the access active on its primary or secondary LNS */
+    isActiveOnLns?: boolean | null;
+    /** Is the modem connected ? */
+    isModemConnected?: boolean | null;
+    /** Test details by line */
+    lineDetails?: XdslAccessDiagnosticLineDetailsList | null;
+    /** Is there an ongoing scheduled maintenance by operator on the access ? */
+    maintenance?: boolean | null;
+    /** Does the access ping ? */
+    ping?: boolean | null;
+    /** Remaining number of diagnostic for this access */
+    remaining?: number;
+}
+export declare const XdslAccessDiagnostic: S.Schema<XdslAccessDiagnostic>;
+export interface GetXdslEmailProRequest {
+    /** Email */
+    email: string;
+}
+export declare const GetXdslEmailProRequest: S.Schema<GetXdslEmailProRequest>;
+/** complexType.UnitAndValue_double */
+export interface ComplexTypeUnitAndValueDouble {
+    unit?: string;
+    value?: number;
+}
+export declare const ComplexTypeUnitAndValueDouble: S.Schema<ComplexTypeUnitAndValueDouble>;
+/** complexType.UnitAndValue_long */
+export type ComplexTypeUnitAndValueLong = ComplexTypeUnitAndValueDouble;
+export declare const ComplexTypeUnitAndValueLong: S.Schema<ComplexTypeUnitAndValueDouble>;
+/** Current object state */
+export type EmailProObjectStateEnum = "creating" | "deleting" | "ok" | "reopening" | "suspended" | "suspending" | "unknown";
+export declare const EmailProObjectStateEnum: any;
+/** XDSL Email Pro */
+export interface XdslXdslEmailProWithIAM {
+    /** Mailbox usage */
+    currentUsage?: ComplexTypeUnitAndValueDouble;
+    /** Account display name */
+    displayName?: string | null;
+    /** Email domain */
+    domain?: string;
+    /** Account first name */
+    firstName?: string | null;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Account id */
+    id?: number;
+    /** Account initials */
+    initial?: string | null;
+    /** Last logoff */
+    lastLogoffDate?: string | null;
+    /** Last logon */
+    lastLogonDate?: string | null;
+    /** Account last name */
+    lastName?: string | null;
+    /** Account login */
+    login?: string;
+    /** Time of account's password last update */
+    passwordLastUpdate?: string | Redacted.Redacted<string> | null;
+    /** Default email for this mailbox */
+    primaryEmailAddress?: string;
+    /** Account maximum size */
+    quota?: ComplexTypeUnitAndValueDouble;
+    /** Account state */
+    state?: EmailProObjectStateEnum;
+    /** Pending tasks for this account */
+    taskPendingId?: number | null;
+}
+export declare const XdslXdslEmailProWithIAM: S.Schema<XdslXdslEmailProWithIAM>;
+export interface GetXdslFiberEligibilityRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetXdslFiberEligibilityRequest: S.Schema<GetXdslFiberEligibilityRequest>;
+/** Copper grid closure trajectory */
+export interface XdslCopperGridClosureTrajectory {
+    /** Commercial closure announcement date */
+    commercialClosureAnnouncementDate?: string | null;
+    /** Commercial closure date */
+    commercialClosureDate?: string | null;
+    /** Commercial closure initial date */
+    commercialClosureInitialDate?: string | null;
+    /** Department code */
+    departmentCode?: string;
+    /** Department name */
+    departmentName?: string | null;
+    /** FTTH zone */
+    ftthZone?: string | null;
+    /** INSEE code */
+    inseeCode?: string;
+    /** Lot */
+    lot?: string | null;
+    /** Municipality name */
+    municipalityName?: string;
+    /** OI code */
+    oiCode?: string | null;
+    /** OI name */
+    oiName?: string | null;
+    /** Technical closure announcement date */
+    technicalClosureAnnouncementDate?: string | null;
+    /** Technical closure date */
+    technicalClosureDate?: string | null;
+    /** Technical closure initial date */
+    technicalClosureInitialDate?: string | null;
+}
+export declare const XdslCopperGridClosureTrajectory: S.Schema<XdslCopperGridClosureTrajectory>;
+/** GRT option for an access. */
+export type XdslGtrEnum = "10ho" | "20m_10ho" | "20m_4ho" | "4hno" | "4ho" | "5m_10ho" | "5m_4ho" | "dplus1" | "none";
+export declare const XdslGtrEnum: any;
+/** Available GRTs */
+export type XdslFiberEligibilityGrtsList = Array<XdslGtrEnum>;
+export declare const XdslFiberEligibilityGrtsList: S.Schema<XdslFiberEligibilityGrtsList>;
+/** Details of a provider */
+export interface XdslOffer {
+    /** Offer code */
+    code?: string;
+    /** Offer name */
+    name?: string;
+}
+export declare const XdslOffer: S.Schema<XdslOffer>;
+/** Details of a provider */
+export interface XdslProvider {
+    /** Provider code */
+    code?: string;
+    /** Provider name */
+    name?: string;
+}
+export declare const XdslProvider: S.Schema<XdslProvider>;
+/** Status of the fiber eligibility */
+export type XdslFiberEligibilityStatusEnum = "eligible" | "no_building" | "not_eligible" | "not_yet_eligible";
+export declare const XdslFiberEligibilityStatusEnum: any;
+/** Fiber eligibility */
+export interface XdslFiberEligibility {
+    /** Availability date */
+    availabilityDate?: string | null;
+    /** Building name */
+    buildingName?: string | null;
+    /** Building reference */
+    buildingReference?: string | null;
+    /** Building sequence id */
+    buildingSeqId?: number | null;
+    /** Copper grid closure trajectory */
+    copperGridClosureTrajectory?: XdslCopperGridClosureTrajectory | null;
+    /** First eligible date */
+    firstEligibleDate?: string | null;
+    /** Available GRTs */
+    grts?: XdslFiberEligibilityGrtsList | null;
+    /** Identifier */
+    id?: number;
+    /** Last update date */
+    lastUpdate?: string;
+    /** Offer */
+    offer?: XdslOffer | null;
+    /** Provider */
+    provider?: XdslProvider | null;
+    /** Status */
+    status?: XdslFiberEligibilityStatusEnum;
+}
+export declare const XdslFiberEligibility: S.Schema<XdslFiberEligibility>;
+export interface GetXdslIncidentRequest {
+    /** Id */
+    id: number;
+}
+export declare const GetXdslIncidentRequest: S.Schema<GetXdslIncidentRequest>;
+/** Department list */
+export type XdslIncidentDepartmentsList = Array<string>;
+export declare const XdslIncidentDepartmentsList: S.Schema<XdslIncidentDepartmentsList>;
+/** NRA list */
+export type XdslIncidentNraList = Array<string>;
+export declare const XdslIncidentNraList: S.Schema<XdslIncidentNraList>;
+/** Operators */
+export type XdslOperatorTypeEnum = "collect" | "kosc" | "ovh";
+export declare const XdslOperatorTypeEnum: any;
+/** Operator */
+export type XdslIncidentOperatorsList = Array<XdslOperatorTypeEnum>;
+export declare const XdslIncidentOperatorsList: S.Schema<XdslIncidentOperatorsList>;
+/** Detected incident */
+export interface XdslIncident {
+    comment?: string;
+    /** Estimated start date */
+    creationDate?: string;
+    /** Department list */
+    departments?: XdslIncidentDepartmentsList;
+    /** Estimated end date */
+    endDate?: string | null;
+    /** ID of the incident */
+    id?: number;
+    /** NRA list */
+    nra?: XdslIncidentNraList;
+    /** Operator */
+    operators?: XdslIncidentOperatorsList;
+    /** Task ID on travaux.ovh.com */
+    taskId?: number | null;
+    taskReference?: string | null;
+}
+export declare const XdslIncident: S.Schema<XdslIncident>;
+export interface GetXdslIncidentRequest2 {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslIncidentRequest2: S.Schema<GetXdslIncidentRequest2>;
+export interface GetXdslIpsRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const GetXdslIpsRequest: S.Schema<GetXdslIpsRequest>;
+export type XdslIPDnsListList = Array<string>;
+export declare const XdslIPDnsListList: S.Schema<XdslIPDnsListList>;
+/** Status of an IP. */
+export type XdslIpStatusEnum = "active" | "close" | "toDelete";
+export declare const XdslIpStatusEnum: any;
+/** Ip versions */
+export type CoreTypesIpVersionEnum = "v4" | "v6";
+export declare const CoreTypesIpVersionEnum: any;
+/** Informations about an IP address */
+export interface XdslIP {
+    dnsList?: XdslIPDnsListList;
+    /** The IP address */
+    ip?: string;
+    range?: number;
+    /** status of the IP */
+    status?: XdslIpStatusEnum;
+    version?: CoreTypesIpVersionEnum;
+}
+export declare const XdslIP: S.Schema<XdslIP>;
+export interface GetXdslLineRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+}
+export declare const GetXdslLineRequest: S.Schema<GetXdslLineRequest>;
+/** Infos about a Landline at the concentration point */
+export interface XdslLandlineConcentrationPoint {
+    /** Identifier of the head of the cable from the MDF */
+    lineHead?: string;
+    /** Identifier of the section at the lineHead */
+    lineInitialSection?: number;
+    /** Identifier of the pair at the lineHead's lineInitialSection */
+    lineInitialSectionPair?: number;
+}
+export declare const XdslLandlineConcentrationPoint: S.Schema<XdslLandlineConcentrationPoint>;
+/** Deconsolidation of the line. */
+export type XdslDeconsolidationEnum = "createNeighbour" | "creation" | "creationNeighbour" | "partial" | "total";
+export declare const XdslDeconsolidationEnum: any;
+/** Maximum time needed to repair a landline */
+export type XdslFaultRepairTimeEnum = "10HO" | "4HNO" | "4HO" | "DPLUS1" | "NORMAL";
+export declare const XdslFaultRepairTimeEnum: any;
+/** xdsl.LineSectionLength */
+export interface XdslLineSectionLength {
+    /** The diameter of this section in millimeters */
+    diameter?: number;
+    /** The length of this section in meters */
+    length?: number;
+}
+export declare const XdslLineSectionLength: S.Schema<XdslLineSectionLength>;
+/** Detailed information about the sections between the DSLAM and the telephone jack */
+export type XdslLineLineSectionsLengthList = Array<XdslLineSectionLength>;
+export declare const XdslLineLineSectionsLengthList: S.Schema<XdslLineLineSectionsLengthList>;
+/** Information about the physical copper line */
+export interface XdslLine {
+    /** Data to identify the line at the concentration point */
+    concentrationPoint?: XdslLandlineConcentrationPoint | null;
+    deconsolidation?: XdslDeconsolidationEnum;
+    /** True if the line is directly wired on the DSLAM */
+    directDistribution?: boolean | null;
+    /** Distance in meters from the DSLAM */
+    distance?: number;
+    faultRepairTime?: XdslFaultRepairTimeEnum;
+    /** Detailed information about the sections between the DSLAM and the telephone jack */
+    lineSectionsLength?: XdslLineLineSectionsLengthList;
+    /** Mitigation of the line in dB */
+    mitigation?: number;
+    /** The number of the line */
+    number?: string;
+    /** The number used to place the order. Null if the same as the current number. */
+    originalNumber?: string | null;
+    /** Whether the line number has been ported to OVH, to be used with VoIP service */
+    portability?: boolean;
+    /** The download synchronisation on the DSLAM in Kbps */
+    syncDown?: number | null;
+    /** The upload synchronisation on the DSLAM in Kbps */
+    syncUp?: number | null;
+}
+export declare const XdslLine: S.Schema<XdslLine>;
+export interface GetXdslLineDslamPortRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+}
+export declare const GetXdslLineDslamPortRequest: S.Schema<GetXdslLineDslamPortRequest>;
+/** Profile on the DSLAM */
+export interface XdslDslamLineProfile {
+    id?: number;
+    isCurrent?: boolean;
+    name?: string;
+}
+export declare const XdslDslamLineProfile: S.Schema<XdslDslamLineProfile>;
+/** Different states of a DSLAM port */
+export type XdslDslamPortStatusEnum = "activated" | "deactivated" | "outofsync";
+export declare const XdslDslamPortStatusEnum: any;
+/** Information about the port on the DSLAM */
+export interface XdslDslamPort {
+    /** Last time the port lost the synchronization */
+    lastDesyncDate?: string | null;
+    /** Last time the port synchronized */
+    lastSyncDate?: string | null;
+    profile?: XdslDslamLineProfile | null;
+    status?: XdslDslamPortStatusEnum;
+}
+export declare const XdslDslamPort: S.Schema<XdslDslamPort>;
+export interface GetXdslModemRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslModemRequest: S.Schema<GetXdslModemRequest>;
+/** ACS backend used by the modem */
+export type XdslXdslModemConfigACSBackendEnum = "beta" | "dev" | "stable";
+export declare const XdslXdslModemConfigACSBackendEnum: any;
+/** Describe the capabilities of the Modem */
+export interface XdslModemCapabilities {
+    canBeManagedByOvh?: boolean;
+    canChangeACS?: boolean;
+    canChangeBridgeMode?: boolean;
+    canChangeDHCP?: boolean;
+    canChangeDMZ?: boolean;
+    canChangeEasyFirewallLevel?: boolean;
+    canChangeFirmware?: boolean;
+    canChangeLAN?: boolean;
+    canChangeManagement?: boolean;
+    canChangeMtu?: boolean;
+    canChangePortMapping?: boolean;
+    canChangeWLAN?: boolean;
+    canChangeWifiRadio?: boolean;
+    canChangeWifiSSID?: boolean;
+    canReboot?: boolean;
+    canReconfigureVoip?: boolean;
+    canRefreshConnectedDevices?: boolean;
+    canReset?: boolean;
+    canUseWifiRadio?: boolean;
+}
+export declare const XdslModemCapabilities: S.Schema<XdslModemCapabilities>;
+/** Level of the Firewall ( BlockAll will block all connections, Normal will block all incoming connections except those in PortMapping and let go all outgoing connections , Disabled will disable all the Firewall and let all incoming or outgoing connections pass through ) */
+export type XdslXdslModemConfigEasyFirewallLevelEnum = "BlockAll" | "Disabled" | "Normal";
+export declare const XdslXdslModemConfigEasyFirewallLevelEnum: any;
+/** Modem */
+export interface XdslModem {
+    /** ACS backend used by the modem */
+    acsBackend?: XdslXdslModemConfigACSBackendEnum;
+    /** Version of ACS API used */
+    acsVersion?: string | null;
+    brandName?: string;
+    capabilities?: XdslModemCapabilities;
+    /** IP Address of the DMZ (To modify or delete the DMZ IP on the modem, a re-configuration of your modem has to be made, your configuration will be maintained, but you will lose your connection a few minutes) */
+    dmzIP?: string | null;
+    /** Level of the FireWall on the modem */
+    easyFirewallLevel?: XdslXdslModemConfigEasyFirewallLevelEnum | null;
+    /** Whether or not the modem supports IPv6 */
+    ipv6Support?: boolean;
+    /** Whether or not the modem is in bridge mode. To pass from bridge mode to routed mode, a reset is necessary. If the modem is managedByOvh, the bridge state will be kept after a reset */
+    isBridged?: boolean;
+    /** Last time the modem made a CWMP request to the Auto Configuration Server */
+    lastCwmpRequestDate?: string | null;
+    macAddress?: string;
+    /** Whether or not the user can configure his modem via OVH Interface (will lock telnet and local HTTP configuration page) */
+    managedByOvh?: boolean;
+    model?: string;
+    /** Size of the Maximum Transmission Unit on the modem's interfaces */
+    mtuSize?: XdslXdslModemConfigMTUSizeEnum | null;
+    serialNumber?: string;
+}
+export declare const XdslModem: S.Schema<XdslModem>;
+export interface GetXdslModemConnectedDeviceRequest {
+    /** Service name */
+    serviceName: string;
+    /** Mac address */
+    macAddress: string;
+}
+export declare const GetXdslModemConnectedDeviceRequest: S.Schema<GetXdslModemConnectedDeviceRequest>;
+/** How did the device got its IP Address */
+export type XdslXdslModemConfigConnectedDeviceAddressSourceEnum = "DHCP" | "Static" | "Unknown";
+export declare const XdslXdslModemConfigConnectedDeviceAddressSourceEnum: any;
+/** Connected Device */
+export interface XdslConnectedDevice {
+    /** The state of this device on the modem */
+    active?: boolean;
+    /** How did the device got its IP address */
+    addressSource?: XdslXdslModemConfigConnectedDeviceAddressSourceEnum;
+    /** Host name given by the device to the modem */
+    hostName?: string;
+    /** The date time of the last update of thoses information */
+    informationDate?: string;
+    /** On which interface is connected the device */
+    interfaceType?: string;
+    /** The IP address of the device */
+    ipAddress?: string;
+    /** The remaining time in seconds of the DHCP lease of this device (-1 means infinite) */
+    leaseTimeRemaining?: number;
+    /** MAC address of the device */
+    macAddress?: string;
+}
+export declare const XdslConnectedDevice: S.Schema<XdslConnectedDevice>;
+export interface GetXdslModemInfoRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslModemInfoRequest: S.Schema<GetXdslModemInfoRequest>;
+/** Describe device information of a Modem */
+export interface XdslDeviceModemInfo {
+    /** Modem brand */
+    brand?: string;
+    /** IPv4 address (e.g., 192.0.2.0) */
+    ip?: string;
+    /** Time of last information refresh */
+    lastUpdate?: string;
+    /** Modem mac address */
+    macAddress?: string;
+    /** Modem type of model */
+    model?: string;
+    /** Organizational Unique Identifier */
+    oui?: string;
+    /** Protocol used for connection */
+    overEthernet?: string | null;
+    /** login used for ppp protocol */
+    pppLogin?: string | null;
+    /** Modem serial key */
+    serial?: string;
+    /** Software Version */
+    softVersion?: string;
+}
+export declare const XdslDeviceModemInfo: S.Schema<XdslDeviceModemInfo>;
+/** Describe statistics information of a Modem */
+export interface XdslStatsModemInfo {
+    /** Connection uptime */
+    connectionUptime?: number;
+    /** Amount of CRC error detected */
+    crcError?: number;
+    /** Modem uptime */
+    deviceUptime?: number;
+    /** Downstream attenuation */
+    downstreamAttenuation?: number;
+    /** Downstream margin */
+    downstreamMargin?: number;
+    /** Downstream synchronization */
+    downstreamSync?: number;
+    /** Amount of FEC error detected */
+    fecError?: number;
+    /** Amount of HEC error detected */
+    hecError?: number;
+    /** Time of last refresh */
+    lastUpdate?: string;
+    /** Line modulation used */
+    modulation?: string;
+    /** Count from last refresh in seconds */
+    quarterHourStart?: number;
+    /** Synchronization uptime */
+    syncUptime?: number;
+    /** Upstream attenuation */
+    upstreamAttenuation?: number;
+    /** Upstream margin */
+    upstreamMargin?: number;
+    /** Upstream synchronization */
+    upstreamSync?: number;
+}
+export declare const XdslStatsModemInfo: S.Schema<XdslStatsModemInfo>;
+/** Describe general information of a Modem */
+export interface XdslModemInfo {
+    /** Describe device information of a Modem */
+    device?: XdslDeviceModemInfo;
+    /** Describe statistics information of a Modem */
+    statistics?: XdslStatsModemInfo;
+}
+export declare const XdslModemInfo: S.Schema<XdslModemInfo>;
+/** AsyncTask status */
+export type XdslAsyncTaskStatusEnum = "error" | "ok" | "pending";
+export declare const XdslAsyncTaskStatusEnum: any;
+/** xdsl.AsyncTask_xdsl.ModemInfo */
+export interface XdslAsyncTaskXdslModemInfo {
+    error?: string | null;
+    /** Describe general information of a Modem */
+    result?: XdslModemInfo | null;
+    /** AsyncTask status */
+    status?: XdslAsyncTaskStatusEnum;
+}
+export declare const XdslAsyncTaskXdslModemInfo: S.Schema<XdslAsyncTaskXdslModemInfo>;
+export interface GetXdslModemLanRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+}
+export declare const GetXdslModemLanRequest: S.Schema<GetXdslModemLanRequest>;
+/** LAN Configuration of the Modem */
+export interface XdslLAN {
+    /** IP address (e.g., 192.0.2.0) */
+    IPAddress?: string;
+    /** How the modem gets its LAN IP Address */
+    addressingType?: XdslXdslModemConfigAddressingTypeEnum;
+    /** Name of the LAN */
+    lanName?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    subnetMask?: string;
+    /** ID of the ongoing todo (NULL if none) */
+    taskId?: number | null;
+}
+export declare const XdslLAN: S.Schema<XdslLAN>;
+export interface GetXdslModemLanDhcpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+}
+export declare const GetXdslModemLanDhcpRequest: S.Schema<GetXdslModemLanDhcpRequest>;
+/** DHCP Configuration of the Modem */
+export interface XdslDHCP {
+    /** IP address (e.g., 192.0.2.0) */
+    defaultGateway?: string;
+    /** Name of the DHCP */
+    dhcpName?: string;
+    /** Domain name provided to the clients */
+    domainName?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    endAddress?: string;
+    /** Lease time in seconds of client assigned address (-1 means infinite) */
+    leaseTime?: number;
+    /** IP address (e.g., 192.0.2.0) */
+    primaryDNS?: string;
+    /** Secondary DNS servers to be given to the clients */
+    secondaryDNS?: string | null;
+    /** State of the DHCP server of the modem */
+    serverEnabled?: boolean;
+    /** IP address (e.g., 192.0.2.0) */
+    startAddress?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    subnetMask?: string;
+    /** ID of the ongoing todo (NULL if none) */
+    taskId?: number | null;
+}
+export declare const XdslDHCP: S.Schema<XdslDHCP>;
+export interface GetXdslModemWifiRequest {
+    /** Service name */
+    serviceName: string;
+    /** Wifi name */
+    wifiName: string;
+}
+export declare const GetXdslModemWifiRequest: S.Schema<GetXdslModemWifiRequest>;
+/** Type of WLAN security protection */
+export type XdslXdslModemConfigSecurityTypeEnum = "None" | "WEP" | "WPA" | "WPA2" | "WPA2andWPA3" | "WPA3" | "WPAandWPA2";
+export declare const XdslXdslModemConfigSecurityTypeEnum: any;
+/** WLAN Configuration of the Modem */
+export interface XdslWLAN {
+    /** Service Set Identifier of the WLAN interface */
+    SSID?: string;
+    /** Hide or show the Wifi */
+    SSIDAdvertisementEnabled?: boolean;
+    /** Indicate if frequencies 2.4GHz and 5GHz are agregated */
+    bandSteering?: boolean;
+    /** Choice of a channel (When chosen, channelMode is set to Manual) */
+    channel?: number;
+    /** How the WiFi channel is selected */
+    channelMode?: XdslXdslModemConfigChannelModeEnum;
+    /** Wifi state */
+    enabled?: boolean;
+    /** Frequency (2.4GHz | 5GHz) */
+    frequency?: XdslXdslModemConfigFrequencyEnum;
+    /** Indicate if it is normal access wifi or guest wifi */
+    guest?: boolean;
+    /** WiFi security key */
+    securityKey?: string;
+    /** Type of WLAN security protection */
+    securityType?: XdslXdslModemConfigSecurityTypeEnum;
+    /** ID of the ongoing todo (NULL if none) */
+    taskId?: number | null;
+    /** Name of the Wifi */
+    wifiName?: string;
+}
+export declare const XdslWLAN: S.Schema<XdslWLAN>;
+export interface GetXdslModemWifiQrCodeRequest {
+    /** Service name */
+    serviceName: string;
+    /** Wifi name */
+    wifiName: string;
+}
+export declare const GetXdslModemWifiQrCodeRequest: S.Schema<GetXdslModemWifiQrCodeRequest>;
+export type GetXdslModemWifiQrCodeResponse = string;
+export declare const GetXdslModemWifiQrCodeResponse: S.Schema<GetXdslModemWifiQrCodeResponse>;
+export interface GetXdslModemWifiRadioRequest {
+    /** Service name */
+    serviceName: string;
+    /** Radio name */
+    radioName: string;
+}
+export declare const GetXdslModemWifiRadioRequest: S.Schema<GetXdslModemWifiRadioRequest>;
+/** Supported channels by this radio */
+export type XdslWifiRadioSupportedChannelsList = Array<number>;
+export declare const XdslWifiRadioSupportedChannelsList: S.Schema<XdslWifiRadioSupportedChannelsList>;
+/** Supported transmit power levels as percentage of full power */
+export type XdslWifiRadioSupportedPowersList = Array<number>;
+export declare const XdslWifiRadioSupportedPowersList: S.Schema<XdslWifiRadioSupportedPowersList>;
+/** Supported IEEE 802.11 standards by this radio */
+export type XdslWifiRadioSupportedStandardsList = Array<string>;
+export declare const XdslWifiRadioSupportedStandardsList: S.Schema<XdslWifiRadioSupportedStandardsList>;
+/** Wifi Radio Configuration of the Modem */
+export interface XdslWifiRadio {
+    /** Current radio channel */
+    channel?: number;
+    /** Current bandwidth of operating channel */
+    channelBandwidth?: string;
+    /** Change channel selection mode (auto | manual) */
+    channelMode?: XdslXdslModemConfigChannelModeEnum;
+    /** Wifi Radio state */
+    enabled?: boolean;
+    /** Frequency (2.4GHz | 5GHz) */
+    frequency?: XdslXdslModemConfigFrequencyEnum;
+    /** The maximum bitrate supported by this interface in Mbps */
+    maxBitRate?: number;
+    /** Name of the Wifi Radio */
+    radioName?: string;
+    /** Current radio IEEE 802.11 standards */
+    standards?: string;
+    /** Supported channels by this radio */
+    supportedChannels?: XdslWifiRadioSupportedChannelsList;
+    /** Supported transmit power levels as percentage of full power */
+    supportedPowers?: XdslWifiRadioSupportedPowersList;
+    /** Supported IEEE 802.11 standards by this radio */
+    supportedStandards?: XdslWifiRadioSupportedStandardsList;
+    /** Current transmit power level */
+    transmitPower?: number;
+}
+export declare const XdslWifiRadio: S.Schema<XdslWifiRadio>;
+export interface GetXdslOntRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslOntRequest: S.Schema<GetXdslOntRequest>;
+/** Access ONT information */
+export interface XdslOnt {
+    /** MAC address of the device */
+    mac?: string;
+    /** Serial of the device */
+    serial?: string;
+}
+export declare const XdslOnt: S.Schema<XdslOnt>;
+export interface GetXdslPendingActionRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslPendingActionRequest: S.Schema<GetXdslPendingActionRequest>;
+/** Scheduled action before the next renewal of the service */
+export interface XdslPendingAction {
+    action?: string;
+    dateTodo?: string;
+}
+export declare const XdslPendingAction: S.Schema<XdslPendingAction>;
+export interface GetXdslResiliationFollowupRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslResiliationFollowupRequest: S.Schema<GetXdslResiliationFollowupRequest>;
+/** Details about the resiliation */
+export interface XdslResiliationFollowUpDetail {
+    /** Date when the resiliation will take effect */
+    dateTodo?: string;
+    /** If the customer needs to return his modem */
+    needModemReturn?: boolean;
+    /** Date when the resiliation was done */
+    registrationDate?: string;
+    /** Status of the resiliation */
+    status?: string;
+}
+export declare const XdslResiliationFollowUpDetail: S.Schema<XdslResiliationFollowUpDetail>;
+export interface GetXdslResiliationTermsRequest {
+    /** Service name */
+    serviceName: string;
+    /** The desired resiliation date */
+    resiliationDate?: string;
+}
+export declare const GetXdslResiliationTermsRequest: S.Schema<GetXdslResiliationTermsRequest>;
+/** Reason of a resiliation */
+export type XdslResiliationReasonEnum = "addressMove" | "billingProblems" | "cessationOfActivity" | "changeOfTerms" | "ftth" | "goToCompetitor" | "other" | "technicalProblems";
+export declare const XdslResiliationReasonEnum: any;
+/** List of available resiliation reasons */
+export type XdslResiliationTermsResiliationReasonsList = Array<XdslResiliationReasonEnum>;
+export declare const XdslResiliationTermsResiliationReasonsList: S.Schema<XdslResiliationTermsResiliationReasonsList>;
+/** Show the resiliation terms */
+export interface XdslResiliationTerms {
+    /** Price with it's currency and textual representation */
+    due?: OrderPrice;
+    /** Date until which the customer is engaged */
+    engageDate?: string | null;
+    /** Minumum resiliationDate */
+    minResiliationDate?: string;
+    /** Date at which the access will be resiliated */
+    resiliationDate?: string;
+    /** List of available resiliation reasons */
+    resiliationReasons?: XdslResiliationTermsResiliationReasonsList;
+}
+export declare const XdslResiliationTerms: S.Schema<XdslResiliationTerms>;
+export interface GetXdslRmaRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: string;
+}
+export declare const GetXdslRmaRequest: S.Schema<GetXdslRmaRequest>;
+/** Return merchandise authorisation offer type */
+export type TelephonyRmaOfferTypeEnum = "deposit" | "loan" | "purchase";
+export declare const TelephonyRmaOfferTypeEnum: any;
+/** Return merchandise authorisation type */
+export type TelephonyRmaReplaceTypeEnum = "changePhone" | "phoneRestitution" | "undefined";
+export declare const TelephonyRmaReplaceTypeEnum: any;
+/** ISO country codes */
+export type CoreTypesCountryEnum = "ac" | "ad" | "ae" | "af" | "ag" | "ai" | "al" | "am" | "an" | "ao" | "aq" | "ar" | "as" | "at" | "au" | "aw" | "ax" | "az" | "ba" | "bb" | "bd" | "be" | "bf" | "bg" | "bh" | "bi" | "bj" | "bl" | "bm" | "bn" | "bo" | "bq" | "br" | "bs" | "bt" | "bv" | "bw" | "by" | "bz" | "ca" | "cc" | "cd" | "cf" | "cg" | "ch" | "ci" | "ck" | "cl" | "cm" | "cn" | "co" | "cr" | "cs" | "cu" | "cv" | "cw" | "cx" | "cy" | "cz" | "de" | "dj" | "dk" | "dm" | "do" | "dz" | "ec" | "ee" | "eg" | "eh" | "er" | "es" | "et" | "fc" | "fd" | "fi" | "fj" | "fk" | "fm" | "fo" | "fr" | "fx" | "ga" | "gb" | "gd" | "ge" | "gf" | "gg" | "gh" | "gi" | "gl" | "gm" | "gn" | "gp" | "gq" | "gr" | "gs" | "gt" | "gu" | "gw" | "gy" | "hk" | "hm" | "hn" | "hr" | "ht" | "hu" | "id" | "ie" | "il" | "im" | "in" | "io" | "iq" | "ir" | "is" | "it" | "je" | "jm" | "jo" | "jp" | "ke" | "kg" | "kh" | "ki" | "km" | "kn" | "kp" | "kr" | "kw" | "ky" | "kz" | "la" | "lb" | "lc" | "li" | "lk" | "lr" | "ls" | "lt" | "lu" | "lv" | "ly" | "ma" | "mc" | "md" | "me" | "mf" | "mg" | "mh" | "mk" | "ml" | "mm" | "mn" | "mo" | "mp" | "mq" | "mr" | "ms" | "mt" | "mu" | "mv" | "mw" | "mx" | "my" | "mz" | "na" | "nc" | "ne" | "nf" | "ng" | "ni" | "nl" | "no" | "np" | "nr" | "nu" | "nz" | "om" | "pa" | "pe" | "pf" | "pg" | "ph" | "pk" | "pl" | "pm" | "pn" | "pr" | "ps" | "pt" | "pw" | "py" | "qa" | "qc" | "re" | "ro" | "rs" | "ru" | "rw" | "sa" | "sb" | "sc" | "sd" | "se" | "sg" | "sh" | "si" | "sj" | "sk" | "sl" | "sm" | "sn" | "so" | "sr" | "ss" | "st" | "sv" | "sx" | "sy" | "sz" | "tc" | "td" | "tf" | "tg" | "th" | "tj" | "tk" | "tl" | "tm" | "tn" | "to" | "tp" | "tr" | "tt" | "tv" | "tw" | "tz" | "ua" | "ug" | "uk" | "um" | "us" | "uy" | "uz" | "va" | "vc" | "ve" | "vg" | "vi" | "vn" | "vu" | "we" | "wf" | "ws" | "ye" | "yt" | "yu" | "za" | "zm" | "zw";
+export declare const CoreTypesCountryEnum: any;
+/** Contact information structure */
+export interface TelephonyContact {
+    /** Contact address */
+    address?: string | null;
+    /** Contact city */
+    city?: string | null;
+    /** Contact country */
+    country?: CoreTypesCountryEnum | (string & {}) | null;
+    email?: string | null;
+    /** Contact firstname */
+    firstname?: string | null;
+    /** Contact name */
+    name?: string | null;
+    /** Contact organisation */
+    organisation?: string | null;
+    /** Contact phone */
+    phone?: string | null;
+    /** Contact zip */
+    zip?: string | null;
+}
+export declare const TelephonyContact: S.Schema<TelephonyContact>;
+/** Return merchandise authorisation step */
+export type TelephonyRmaStatusEnum = "closed" | "open" | "received";
+export declare const TelephonyRmaStatusEnum: any;
+/** RMA step names */
+export type TelephonyRmaStepNameEnum = "dispatchJustification" | "equipmentSending" | "equipmentTesting" | "opening" | "parcelReception" | "parcelValidation" | "validation";
+export declare const TelephonyRmaStepNameEnum: any;
+/** Status of the RMA step */
+export type TelephonyRmaStepStatusEnum = "done" | "todo";
+export declare const TelephonyRmaStepStatusEnum: any;
+/** Informations related to the current RMA step status */
+export interface TelephonyRmaStep {
+    /** A brief description of the step */
+    description?: string;
+    /** The date when this step was done */
+    doneDate?: string | null;
+    /** Additional information about the step */
+    infos?: string | null;
+    /** RMA step names */
+    name?: TelephonyRmaStepNameEnum;
+    /** Status of the RMA step */
+    status?: TelephonyRmaStepStatusEnum;
+}
+export declare const TelephonyRmaStep: S.Schema<TelephonyRmaStep>;
+/** Indicates the current status of the RMA with a list of steps */
+export type TelephonyRmaStepsList = Array<TelephonyRmaStep>;
+export declare const TelephonyRmaStepsList: S.Schema<TelephonyRmaStepsList>;
+/** Return merchandise authorisation type */
+export type TelephonyRmaTypeEnum = "after sale equipment service exchange" | "after sale phone service exchange" | "equipment restitution" | "fast exchange" | "old merchandise reception before exchange" | "phone restitution" | "resends due to shipping lost by the carrier" | "resends due to shipping not withdraw" | "specific return merchandise authorisation" | "termination" | "unknown";
+export declare const TelephonyRmaTypeEnum: any;
+/** Current Return Merchandise Authorisation */
+export interface TelephonyRma {
+    /** Is the RMA cancellable? */
+    cancellable?: boolean;
+    /** Creation datetime of the return merchandise authorisation ticket */
+    creationDatetime?: string;
+    /** Merchandise reference */
+    equipmentReference?: string;
+    /** Return merchandise authorisation identifier */
+    id?: string;
+    /** New merchandise brand in case of exchange */
+    newMerchandise?: string | null;
+    /** Offer type of the new merchandise in case of exchange */
+    offerTypeNew?: TelephonyRmaOfferTypeEnum | null;
+    /** Offer type of the return merchandise */
+    offerTypeOld?: TelephonyRmaOfferTypeEnum;
+    /** Return merchandise authorisation type */
+    process?: TelephonyRmaReplaceTypeEnum;
+    /** Reception datetime of the return merchandise authorisation ticket */
+    receptionDatetime?: string | null;
+    /** Contact information structure */
+    shippingContact?: TelephonyContact;
+    /** Return merchandise authorisation step */
+    status?: TelephonyRmaStatusEnum;
+    /** Indicates the current status of the RMA with a list of steps */
+    steps?: TelephonyRmaStepsList;
+    /** Termination datetime of the return merchandise authorisation ticket */
+    terminationDatetime?: string | null;
+    /** Typology process of merchandise return */
+    type?: TelephonyRmaTypeEnum;
+}
+export declare const TelephonyRma: S.Schema<TelephonyRma>;
+export interface GetXdslServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslServiceInfosRequest: S.Schema<GetXdslServiceInfosRequest>;
+/** 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" | "manual" | "oneShot" | "option";
+export declare const ServiceRenewalTypeEnum: any;
+/** service.StateEnum */
+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 GetXdslSpareRequest {
+    /** Spare */
+    spare: string;
+}
+export declare const GetXdslSpareRequest: S.Schema<GetXdslSpareRequest>;
+/** Spare properties */
+export interface SpareXdslXdslSpareWithIAM {
+    /** Modem brand model */
+    brand?: string;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Mac address */
+    macAddress?: string;
+}
+export declare const SpareXdslXdslSpareWithIAM: S.Schema<SpareXdslXdslSpareWithIAM>;
+export interface GetXdslSpareServiceInfosRequest {
+    /** Spare */
+    spare: string;
+}
+export declare const GetXdslSpareServiceInfosRequest: S.Schema<GetXdslSpareServiceInfosRequest>;
+export interface GetXdslTaskRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetXdslTaskRequest: S.Schema<GetXdslTaskRequest>;
+export interface GetXdslTotalDeconsolidationTermsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetXdslTotalDeconsolidationTermsRequest: S.Schema<GetXdslTotalDeconsolidationTermsRequest>;
+/** Show the deconsolidation terms */
+export interface XdslDeconsolidationTerms {
+    /** Duration of month the access will be engaged */
+    engagement?: number;
+    /** Price with it's currency and textual representation */
+    monthlyPrice?: OrderPrice;
+    /** Price with it's currency and textual representation */
+    price?: OrderPrice;
+}
+export declare const XdslDeconsolidationTerms: S.Schema<XdslDeconsolidationTerms>;
+export interface InstallFrimwareRequest {
+    /** Service name */
+    serviceName: string;
+    /** The firmware version to upgrade to */
+    firmware: string;
+    /** Date of execution, default is now */
+    todoDate?: string;
+}
+export declare const InstallFrimwareRequest: S.Schema<InstallFrimwareRequest>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListXdslRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListXdslRequestIamTagsValueList: S.Schema<ListXdslRequestIamTagsValueList>;
+export type ListXdslRequestIamTagsMap = {
+    [key: string]: ListXdslRequestIamTagsValueList | undefined;
+};
+export declare const ListXdslRequestIamTagsMap: S.Schema<ListXdslRequestIamTagsMap>;
+export interface ListXdslRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListXdslRequestIamTagsMap;
+}
+export declare const ListXdslRequest: S.Schema<ListXdslRequest>;
+export type ListXdslResponseBodyList = Array<string>;
+export declare const ListXdslResponseBodyList: S.Schema<ListXdslResponseBodyList>;
+export type ListXdslResponse = ListXdslResponseBodyList;
+export declare const ListXdslResponse: S.Schema<ListXdslResponse>;
+export interface ListXdslAntiSpamEvidencesRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const ListXdslAntiSpamEvidencesRequest: S.Schema<ListXdslAntiSpamEvidencesRequest>;
+/** detail on evidences stored on PCS */
+export interface XdslAntiSpamEvidencesInfoDetail {
+    /** File date on the PCS */
+    date?: string;
+    /** File name on the PCS */
+    filename?: string;
+    /** Temporary URL to access file */
+    url?: string;
+}
+export declare const XdslAntiSpamEvidencesInfoDetail: S.Schema<XdslAntiSpamEvidencesInfoDetail>;
+/** Table with evidences stored on PCS */
+export type XdslAntiSpamEvidencesInfoResultList = Array<XdslAntiSpamEvidencesInfoDetail>;
+export declare const XdslAntiSpamEvidencesInfoResultList: S.Schema<XdslAntiSpamEvidencesInfoResultList>;
+/** Evidences AsyncTask status */
+export type XdslAntiSpamEvidencesInfoStatusEnum = "error" | "ok" | "pending";
+export declare const XdslAntiSpamEvidencesInfoStatusEnum: any;
+/** List of evidences */
+export interface XdslAntiSpamEvidencesInfo {
+    /** AsyncTask detailed error */
+    error?: string | null;
+    /** Table with evidences stored on PCS */
+    result?: XdslAntiSpamEvidencesInfoResultList | null;
+    /** Evidences AsyncTask status */
+    status?: XdslAntiSpamEvidencesInfoStatusEnum;
+}
+export declare const XdslAntiSpamEvidencesInfo: S.Schema<XdslAntiSpamEvidencesInfo>;
+export interface ListXdslAntiSpamsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslAntiSpamsRequest: S.Schema<ListXdslAntiSpamsRequest>;
+export type ListXdslAntiSpamsResponseBodyList = Array<string>;
+export declare const ListXdslAntiSpamsResponseBodyList: S.Schema<ListXdslAntiSpamsResponseBodyList>;
+export type ListXdslAntiSpamsResponse = ListXdslAntiSpamsResponseBodyList;
+export declare const ListXdslAntiSpamsResponse: S.Schema<ListXdslAntiSpamsResponse>;
+export type ListXdslEmailProRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListXdslEmailProRequestIamTagsValueList: S.Schema<ListXdslEmailProRequestIamTagsValueList>;
+export type ListXdslEmailProRequestIamTagsMap = {
+    [key: string]: ListXdslEmailProRequestIamTagsValueList | undefined;
+};
+export declare const ListXdslEmailProRequestIamTagsMap: S.Schema<ListXdslEmailProRequestIamTagsMap>;
+export interface ListXdslEmailProRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListXdslEmailProRequestIamTagsMap;
+}
+export declare const ListXdslEmailProRequest: S.Schema<ListXdslEmailProRequest>;
+export type ListXdslEmailProResponseBodyList = Array<string>;
+export declare const ListXdslEmailProResponseBodyList: S.Schema<ListXdslEmailProResponseBodyList>;
+export type ListXdslEmailProResponse = ListXdslEmailProResponseBodyList;
+export declare const ListXdslEmailProResponse: S.Schema<ListXdslEmailProResponse>;
+export interface ListXdslFiberEligibilitiesRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of status property (=) */
+    status?: XdslFiberEligibilityStatusEnum | (string & {});
+}
+export declare const ListXdslFiberEligibilitiesRequest: S.Schema<ListXdslFiberEligibilitiesRequest>;
+export type ListXdslFiberEligibilitiesResponseBodyList = Array<number>;
+export declare const ListXdslFiberEligibilitiesResponseBodyList: S.Schema<ListXdslFiberEligibilitiesResponseBodyList>;
+export type ListXdslFiberEligibilitiesResponse = ListXdslFiberEligibilitiesResponseBodyList;
+export declare const ListXdslFiberEligibilitiesResponse: S.Schema<ListXdslFiberEligibilitiesResponse>;
+export interface ListXdslIncidentsRequest {
+    /** Filter the value of creationDate property (>) */
+    creationDate?: string;
+    /** Filter the value of endDate property (<) */
+    endDate?: string;
+}
+export declare const ListXdslIncidentsRequest: S.Schema<ListXdslIncidentsRequest>;
+export type ListXdslIncidentsResponseBodyList = Array<number>;
+export declare const ListXdslIncidentsResponseBodyList: S.Schema<ListXdslIncidentsResponseBodyList>;
+export type ListXdslIncidentsResponse = ListXdslIncidentsResponseBodyList;
+export declare const ListXdslIncidentsResponse: S.Schema<ListXdslIncidentsResponse>;
+export interface ListXdslIpsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslIpsRequest: S.Schema<ListXdslIpsRequest>;
+export type ListXdslIpsResponseBodyList = Array<string>;
+export declare const ListXdslIpsResponseBodyList: S.Schema<ListXdslIpsResponseBodyList>;
+export type ListXdslIpsResponse = ListXdslIpsResponseBodyList;
+export declare const ListXdslIpsResponse: S.Schema<ListXdslIpsResponse>;
+export interface ListXdslLineDslamPortAvailableProfilesRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+}
+export declare const ListXdslLineDslamPortAvailableProfilesRequest: S.Schema<ListXdslLineDslamPortAvailableProfilesRequest>;
+export type ListXdslLineDslamPortAvailableProfilesResponseBodyList = Array<XdslDslamLineProfile>;
+export declare const ListXdslLineDslamPortAvailableProfilesResponseBodyList: S.Schema<ListXdslLineDslamPortAvailableProfilesResponseBodyList>;
+export type ListXdslLineDslamPortAvailableProfilesResponse = ListXdslLineDslamPortAvailableProfilesResponseBodyList;
+export declare const ListXdslLineDslamPortAvailableProfilesResponse: S.Schema<ListXdslLineDslamPortAvailableProfilesResponse>;
+export interface ListXdslLineDslamPortLogsRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+    limit: number;
+}
+export declare const ListXdslLineDslamPortLogsRequest: S.Schema<ListXdslLineDslamPortLogsRequest>;
+/** A message log from the DSLAM */
+export interface XdslDslamPortLog {
+    date?: string;
+    /** The last time this message occured */
+    lastOccurrenceDate?: string;
+    message?: string;
+    /** The number of times this message occured between date and lastOccurrenceDate */
+    numberOfOccurrences?: number;
+}
+export declare const XdslDslamPortLog: S.Schema<XdslDslamPortLog>;
+export type ListXdslLineDslamPortLogsResponseBodyList = Array<XdslDslamPortLog>;
+export declare const ListXdslLineDslamPortLogsResponseBodyList: S.Schema<ListXdslLineDslamPortLogsResponseBodyList>;
+export type ListXdslLineDslamPortLogsResponse = ListXdslLineDslamPortLogsResponseBodyList;
+export declare const ListXdslLineDslamPortLogsResponse: S.Schema<ListXdslLineDslamPortLogsResponse>;
+export interface ListXdslLinesRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslLinesRequest: S.Schema<ListXdslLinesRequest>;
+export type ListXdslLinesResponseBodyList = Array<string>;
+export declare const ListXdslLinesResponseBodyList: S.Schema<ListXdslLinesResponseBodyList>;
+export type ListXdslLinesResponse = ListXdslLinesResponseBodyList;
+export declare const ListXdslLinesResponse: S.Schema<ListXdslLinesResponse>;
+/** Periods for statistics. */
+export type XdslStatisticsPeriodEnum = "daily" | "monthly" | "preview" | "weekly" | "yearly";
+export declare const XdslStatisticsPeriodEnum: any;
+/** Various types of statisctics available for the line. */
+export type XdslLineStatisticsTypeEnum = "attenuation:download" | "attenuation:upload" | "error:crc" | "error:fec" | "error:hec" | "snr:download" | "snr:upload" | "synchronization:download" | "synchronization:upload";
+export declare const XdslLineStatisticsTypeEnum: any;
+export interface ListXdslLineStatisticsRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+    period: XdslStatisticsPeriodEnum | (string & {});
+    type: XdslLineStatisticsTypeEnum | (string & {});
+}
+export declare const ListXdslLineStatisticsRequest: S.Schema<ListXdslLineStatisticsRequest>;
+/** A value associated to a timestamp */
+export interface XdslTimestampAndValue {
+    timestamp?: number;
+    value?: number | null;
+}
+export declare const XdslTimestampAndValue: S.Schema<XdslTimestampAndValue>;
+export type ComplexTypeUnitAndValuesXdslTimestampAndValueValuesList = Array<XdslTimestampAndValue>;
+export declare const ComplexTypeUnitAndValuesXdslTimestampAndValueValuesList: S.Schema<ComplexTypeUnitAndValuesXdslTimestampAndValueValuesList>;
+/** complexType.UnitAndValues_xdsl.TimestampAndValue */
+export interface ComplexTypeUnitAndValuesXdslTimestampAndValue {
+    unit?: string;
+    values?: ComplexTypeUnitAndValuesXdslTimestampAndValueValuesList;
+}
+export declare const ComplexTypeUnitAndValuesXdslTimestampAndValue: S.Schema<ComplexTypeUnitAndValuesXdslTimestampAndValue>;
+export interface ListXdslModemAvailableACSBackendRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslModemAvailableACSBackendRequest: S.Schema<ListXdslModemAvailableACSBackendRequest>;
+export type ListXdslModemAvailableACSBackendResponseBodyList = Array<string>;
+export declare const ListXdslModemAvailableACSBackendResponseBodyList: S.Schema<ListXdslModemAvailableACSBackendResponseBodyList>;
+export type ListXdslModemAvailableACSBackendResponse = ListXdslModemAvailableACSBackendResponseBodyList;
+export declare const ListXdslModemAvailableACSBackendResponse: S.Schema<ListXdslModemAvailableACSBackendResponse>;
+/** Frequency of WLAN */
+export type XdslWLANFrequencyEnum = "2.4GHz" | "5GHz";
+export declare const XdslWLANFrequencyEnum: any;
+export interface ListXdslModemAvailableWLANChannelRequest {
+    /** Service name */
+    serviceName: string;
+    /** WLAN frequency you want to retrieve channels */
+    frequency: XdslWLANFrequencyEnum | (string & {});
+}
+export declare const ListXdslModemAvailableWLANChannelRequest: S.Schema<ListXdslModemAvailableWLANChannelRequest>;
+export type ListXdslModemAvailableWLANChannelResponseBodyList = Array<number>;
+export declare const ListXdslModemAvailableWLANChannelResponseBodyList: S.Schema<ListXdslModemAvailableWLANChannelResponseBodyList>;
+export type ListXdslModemAvailableWLANChannelResponse = ListXdslModemAvailableWLANChannelResponseBodyList;
+export declare const ListXdslModemAvailableWLANChannelResponse: S.Schema<ListXdslModemAvailableWLANChannelResponse>;
+export interface ListXdslModemConnectedDevicesRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslModemConnectedDevicesRequest: S.Schema<ListXdslModemConnectedDevicesRequest>;
+export type ListXdslModemConnectedDevicesResponseBodyList = Array<string>;
+export declare const ListXdslModemConnectedDevicesResponseBodyList: S.Schema<ListXdslModemConnectedDevicesResponseBodyList>;
+export type ListXdslModemConnectedDevicesResponse = ListXdslModemConnectedDevicesResponseBodyList;
+export declare const ListXdslModemConnectedDevicesResponse: S.Schema<ListXdslModemConnectedDevicesResponse>;
+export interface ListXdslModemFirmwareAvailableRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslModemFirmwareAvailableRequest: S.Schema<ListXdslModemFirmwareAvailableRequest>;
+export type ListXdslModemFirmwareAvailableResponseBodyList = Array<string>;
+export declare const ListXdslModemFirmwareAvailableResponseBodyList: S.Schema<ListXdslModemFirmwareAvailableResponseBodyList>;
+export type ListXdslModemFirmwareAvailableResponse = ListXdslModemFirmwareAvailableResponseBodyList;
+export declare const ListXdslModemFirmwareAvailableResponse: S.Schema<ListXdslModemFirmwareAvailableResponse>;
+export interface ListXdslModemLanRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslModemLanRequest: S.Schema<ListXdslModemLanRequest>;
+export type ListXdslModemLanResponseBodyList = Array<string>;
+export declare const ListXdslModemLanResponseBodyList: S.Schema<ListXdslModemLanResponseBodyList>;
+export type ListXdslModemLanResponse = ListXdslModemLanResponseBodyList;
+export declare const ListXdslModemLanResponse: S.Schema<ListXdslModemLanResponse>;
+export interface ListXdslModemLanDhcpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+}
+export declare const ListXdslModemLanDhcpRequest: S.Schema<ListXdslModemLanDhcpRequest>;
+export type ListXdslModemLanDhcpResponseBodyList = Array<string>;
+export declare const ListXdslModemLanDhcpResponseBodyList: S.Schema<ListXdslModemLanDhcpResponseBodyList>;
+export type ListXdslModemLanDhcpResponse = ListXdslModemLanDhcpResponseBodyList;
+export declare const ListXdslModemLanDhcpResponse: S.Schema<ListXdslModemLanDhcpResponse>;
+export interface ListXdslModemWifiRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslModemWifiRequest: S.Schema<ListXdslModemWifiRequest>;
+export type ListXdslModemWifiResponseBodyList = Array<string>;
+export declare const ListXdslModemWifiResponseBodyList: S.Schema<ListXdslModemWifiResponseBodyList>;
+export type ListXdslModemWifiResponse = ListXdslModemWifiResponseBodyList;
+export declare const ListXdslModemWifiResponse: S.Schema<ListXdslModemWifiResponse>;
+export interface ListXdslModemWifiRadioRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslModemWifiRadioRequest: S.Schema<ListXdslModemWifiRadioRequest>;
+export type ListXdslModemWifiRadioResponseBodyList = Array<string>;
+export declare const ListXdslModemWifiRadioResponseBodyList: S.Schema<ListXdslModemWifiRadioResponseBodyList>;
+export type ListXdslModemWifiRadioResponse = ListXdslModemWifiRadioResponseBodyList;
+export declare const ListXdslModemWifiRadioResponse: S.Schema<ListXdslModemWifiRadioResponse>;
+export interface ListXdslOrderFollowupRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslOrderFollowupRequest: S.Schema<ListXdslOrderFollowupRequest>;
+export type XdslOrderFollowupStepCommentsList = Array<string>;
+export declare const XdslOrderFollowupStepCommentsList: S.Schema<XdslOrderFollowupStepCommentsList>;
+/** The duration units */
+export type XdslOrderFollowupDurationUnitEnum = "day" | "hour" | "minute";
+export declare const XdslOrderFollowupDurationUnitEnum: any;
+/** The status of an order step */
+export type XdslOrderFollowupStepNameEnum = "accessIsOperational" | "checkInfrastructure" | "configureAccessOnOVH" | "orderPayed" | "orderReceived" | "orderTreatment" | "sendModem" | "sendOrderToProvider" | "setupCustomerPremisesEquipment" | "waitingForProviderInstallReport" | "waitingForWithdrawalPeriodToBeOver";
+export declare const XdslOrderFollowupStepNameEnum: any;
+/** The status of an order step */
+export type XdslOrderFollowupStepStatusEnum = "doing" | "done" | "error" | "todo" | "waitingCustomer";
+export declare const XdslOrderFollowupStepStatusEnum: any;
+/** A step of the order process */
+export interface XdslOrderFollowupStep {
+    comments?: XdslOrderFollowupStepCommentsList;
+    doneDate?: string | null;
+    /** The duration units */
+    durationUnit?: XdslOrderFollowupDurationUnitEnum;
+    expectedDuration?: number;
+    /** The status of an order step */
+    name?: XdslOrderFollowupStepNameEnum;
+    /** The status of an order step */
+    status?: XdslOrderFollowupStepStatusEnum;
+}
+export declare const XdslOrderFollowupStep: S.Schema<XdslOrderFollowupStep>;
+export type ListXdslOrderFollowupResponseBodyList = Array<XdslOrderFollowupStep>;
+export declare const ListXdslOrderFollowupResponseBodyList: S.Schema<ListXdslOrderFollowupResponseBodyList>;
+export type ListXdslOrderFollowupResponse = ListXdslOrderFollowupResponseBodyList;
+export declare const ListXdslOrderFollowupResponse: S.Schema<ListXdslOrderFollowupResponse>;
+export interface ListXdslRadiusConnectionLogsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslRadiusConnectionLogsRequest: S.Schema<ListXdslRadiusConnectionLogsRequest>;
+/** Log entry of an auth attempt to the radius server */
+export interface XdslRadiusConnectionLog {
+    date?: string;
+    login?: string;
+    message?: string;
+    state?: string;
+}
+export declare const XdslRadiusConnectionLog: S.Schema<XdslRadiusConnectionLog>;
+export type ListXdslRadiusConnectionLogsResponseBodyList = Array<XdslRadiusConnectionLog>;
+export declare const ListXdslRadiusConnectionLogsResponseBodyList: S.Schema<ListXdslRadiusConnectionLogsResponseBodyList>;
+export type ListXdslRadiusConnectionLogsResponse = ListXdslRadiusConnectionLogsResponseBodyList;
+export declare const ListXdslRadiusConnectionLogsResponse: S.Schema<ListXdslRadiusConnectionLogsResponse>;
+export interface ListXdslRmaRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListXdslRmaRequest: S.Schema<ListXdslRmaRequest>;
+export type ListXdslRmaResponseBodyList = Array<string>;
+export declare const ListXdslRmaResponseBodyList: S.Schema<ListXdslRmaResponseBodyList>;
+export type ListXdslRmaResponse = ListXdslRmaResponseBodyList;
+export declare const ListXdslRmaResponse: S.Schema<ListXdslRmaResponse>;
+export type ListXdslSpareRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListXdslSpareRequestIamTagsValueList: S.Schema<ListXdslSpareRequestIamTagsValueList>;
+export type ListXdslSpareRequestIamTagsMap = {
+    [key: string]: ListXdslSpareRequestIamTagsValueList | undefined;
+};
+export declare const ListXdslSpareRequestIamTagsMap: S.Schema<ListXdslSpareRequestIamTagsMap>;
+export interface ListXdslSpareRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListXdslSpareRequestIamTagsMap;
+}
+export declare const ListXdslSpareRequest: S.Schema<ListXdslSpareRequest>;
+export type ListXdslSpareResponseBodyList = Array<string>;
+export declare const ListXdslSpareResponseBodyList: S.Schema<ListXdslSpareResponseBodyList>;
+export type ListXdslSpareResponse = ListXdslSpareResponseBodyList;
+export declare const ListXdslSpareResponse: S.Schema<ListXdslSpareResponse>;
+export interface ListXdslSpareBrandsRequest {
+}
+export declare const ListXdslSpareBrandsRequest: S.Schema<ListXdslSpareBrandsRequest>;
+export type ListXdslSpareBrandsResponseBodyList = Array<string>;
+export declare const ListXdslSpareBrandsResponseBodyList: S.Schema<ListXdslSpareBrandsResponseBodyList>;
+export type ListXdslSpareBrandsResponse = ListXdslSpareBrandsResponseBodyList;
+export declare const ListXdslSpareBrandsResponse: S.Schema<ListXdslSpareBrandsResponse>;
+export interface ListXdslSpareCompatibleReplacementRequest {
+    /** Spare */
+    spare: string;
+}
+export declare const ListXdslSpareCompatibleReplacementRequest: S.Schema<ListXdslSpareCompatibleReplacementRequest>;
+export type ListXdslSpareCompatibleReplacementResponseBodyList = Array<string>;
+export declare const ListXdslSpareCompatibleReplacementResponseBodyList: S.Schema<ListXdslSpareCompatibleReplacementResponseBodyList>;
+export type ListXdslSpareCompatibleReplacementResponse = ListXdslSpareCompatibleReplacementResponseBodyList;
+export declare const ListXdslSpareCompatibleReplacementResponse: S.Schema<ListXdslSpareCompatibleReplacementResponse>;
+/** Various types of statisctics available for the access. */
+export type XdslAccessStatisticsTypeEnum = "ping" | "traffic:download" | "traffic:upload";
+export declare const XdslAccessStatisticsTypeEnum: any;
+export interface ListXdslStatisticsRequest {
+    /** Service name */
+    serviceName: string;
+    period: XdslStatisticsPeriodEnum | (string & {});
+    type: XdslAccessStatisticsTypeEnum | (string & {});
+}
+export declare const ListXdslStatisticsRequest: S.Schema<ListXdslStatisticsRequest>;
+/** An access latency item */
+export interface XdslAccessLatency {
+    loss?: number | null;
+    status?: number | null;
+    timestamp?: number;
+    value?: number | null;
+    verboseStatus?: string | null;
+}
+export declare const XdslAccessLatency: S.Schema<XdslAccessLatency>;
+export type ComplexTypeUnitAndValuesXdslAccessLatencyValuesList = Array<XdslAccessLatency>;
+export declare const ComplexTypeUnitAndValuesXdslAccessLatencyValuesList: S.Schema<ComplexTypeUnitAndValuesXdslAccessLatencyValuesList>;
+/** complexType.UnitAndValues_xdsl.AccessLatency */
+export interface ComplexTypeUnitAndValuesXdslAccessLatency {
+    unit?: string;
+    values?: ComplexTypeUnitAndValuesXdslAccessLatencyValuesList;
+}
+export declare const ComplexTypeUnitAndValuesXdslAccessLatency: S.Schema<ComplexTypeUnitAndValuesXdslAccessLatency>;
+export interface ListXdslTasksRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of function property (=) */
+    function?: string;
+    /** Filter the value of status property (=) */
+    status?: XdslTaskStatusEnum | (string & {});
+}
+export declare const ListXdslTasksRequest: S.Schema<ListXdslTasksRequest>;
+export type ListXdslTasksResponseBodyList = Array<number>;
+export declare const ListXdslTasksResponseBodyList: S.Schema<ListXdslTasksResponseBodyList>;
+export type ListXdslTasksResponse = ListXdslTasksResponseBodyList;
+export declare const ListXdslTasksResponse: S.Schema<ListXdslTasksResponse>;
+export interface PutXdslRequest {
+    /** Service name */
+    serviceName: string;
+    description?: string;
+    /** Rate limit on the LNS in kbps - Only available if canApplyLnsRateLimit capability is set to true - Must be a multiple of 64 - Min value 64 / Max value 100032 */
+    lnsRateLimit?: number | null;
+    /** Whether or not this access is monitored */
+    monitoring?: boolean;
+}
+export declare const PutXdslRequest: S.Schema<PutXdslRequest>;
+export interface PutXdslResponse {
+}
+export declare const PutXdslResponse: S.Schema<PutXdslResponse>;
+export interface PutXdslEmailProRequest {
+    /** Email */
+    email: string;
+    /** Account display name */
+    displayName?: string | null;
+    /** Account first name */
+    firstName?: string | null;
+    /** Account initials */
+    initial?: string | null;
+    /** Account last name */
+    lastName?: string | null;
+}
+export declare const PutXdslEmailProRequest: S.Schema<PutXdslEmailProRequest>;
+export interface PutXdslEmailProResponse {
+}
+export declare const PutXdslEmailProResponse: S.Schema<PutXdslEmailProResponse>;
+export interface PutXdslModemRequest {
+    /** Service name */
+    serviceName: string;
+    /** ACS backend used by the modem */
+    acsBackend?: XdslXdslModemConfigACSBackendEnum | (string & {});
+    /** IP Address of the DMZ (To modify or delete the DMZ IP on the modem, a re-configuration of your modem has to be made, your configuration will be maintained, but you will lose your connection a few minutes) */
+    dmzIP?: string | null;
+    /** Whether or not the modem is in bridge mode. To pass from bridge mode to routed mode, a reset is necessary. If the modem is managedByOvh, the bridge state will be kept after a reset */
+    isBridged?: boolean;
+    /** Whether or not the user can configure his modem via OVH Interface (will lock telnet and local HTTP configuration page) */
+    managedByOvh?: boolean;
+    /** Size of the Maximum Transmission Unit on the modem's interfaces */
+    mtuSize?: XdslXdslModemConfigMTUSizeEnum | (number & {}) | null;
+}
+export declare const PutXdslModemRequest: S.Schema<PutXdslModemRequest>;
+export interface PutXdslModemResponse {
+}
+export declare const PutXdslModemResponse: S.Schema<PutXdslModemResponse>;
+export interface PutXdslModemLanRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** IP address (e.g., 192.0.2.0) */
+    IPAddress?: string;
+    /** How the modem gets its LAN IP Address */
+    addressingType?: XdslXdslModemConfigAddressingTypeEnum | (string & {});
+    /** IP address (e.g., 192.0.2.0) */
+    subnetMask?: string;
+}
+export declare const PutXdslModemLanRequest: S.Schema<PutXdslModemLanRequest>;
+export interface PutXdslModemLanResponse {
+}
+export declare const PutXdslModemLanResponse: S.Schema<PutXdslModemLanResponse>;
+export interface PutXdslModemLanDhcpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+    /** IP address (e.g., 192.0.2.0) */
+    defaultGateway?: string;
+    /** Domain name provided to the clients */
+    domainName?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    endAddress?: string;
+    /** Lease time in seconds of client assigned address (-1 means infinite) */
+    leaseTime?: number;
+    /** IP address (e.g., 192.0.2.0) */
+    primaryDNS?: string;
+    /** Secondary DNS servers to be given to the clients */
+    secondaryDNS?: string | null;
+    /** State of the DHCP server of the modem */
+    serverEnabled?: boolean;
+    /** IP address (e.g., 192.0.2.0) */
+    startAddress?: string;
+    /** IP address (e.g., 192.0.2.0) */
+    subnetMask?: string;
+}
+export declare const PutXdslModemLanDhcpRequest: S.Schema<PutXdslModemLanDhcpRequest>;
+export interface PutXdslModemLanDhcpResponse {
+}
+export declare const PutXdslModemLanDhcpResponse: S.Schema<PutXdslModemLanDhcpResponse>;
+export interface PutXdslModemWifiRequest {
+    /** Service name */
+    serviceName: string;
+    /** Wifi name */
+    wifiName: string;
+    /** Service Set Identifier of the WLAN interface */
+    SSID?: string;
+    /** Hide or show the Wifi */
+    SSIDAdvertisementEnabled?: boolean;
+    /** Choice of a channel (When chosen, channelMode is set to Manual) */
+    channel?: number;
+    /** How the WiFi channel is selected */
+    channelMode?: XdslXdslModemConfigChannelModeEnum | (string & {});
+    /** Wifi state */
+    enabled?: boolean;
+    /** WiFi security key */
+    securityKey?: string;
+    /** Type of WLAN security protection */
+    securityType?: XdslXdslModemConfigSecurityTypeEnum | (string & {});
+}
+export declare const PutXdslModemWifiRequest: S.Schema<PutXdslModemWifiRequest>;
+export interface PutXdslModemWifiResponse {
+}
+export declare const PutXdslModemWifiResponse: S.Schema<PutXdslModemWifiResponse>;
+export interface PutXdslModemWifiRadioRequest {
+    /** Service name */
+    serviceName: string;
+    /** Radio name */
+    radioName: string;
+    /** Current radio channel */
+    channel?: number;
+    /** Change channel selection mode (auto | manual) */
+    channelMode?: XdslXdslModemConfigChannelModeEnum | (string & {});
+}
+export declare const PutXdslModemWifiRadioRequest: S.Schema<PutXdslModemWifiRadioRequest>;
+export interface PutXdslRmaRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: string;
+    /** Return merchandise authorisation type */
+    process?: TelephonyRmaReplaceTypeEnum | (string & {});
+    /** Contact information structure */
+    shippingContact?: TelephonyContact;
+}
+export declare const PutXdslRmaRequest: S.Schema<PutXdslRmaRequest>;
+export interface PutXdslRmaResponse {
+}
+export declare const PutXdslRmaResponse: S.Schema<PutXdslRmaResponse>;
+export interface PutXdslServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutXdslServiceInfosRequest: S.Schema<PutXdslServiceInfosRequest>;
+export interface PutXdslServiceInfosResponse {
+}
+export declare const PutXdslServiceInfosResponse: S.Schema<PutXdslServiceInfosResponse>;
+export interface PutXdslSpareServiceInfosRequest {
+    /** Spare */
+    spare: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutXdslSpareServiceInfosRequest: S.Schema<PutXdslSpareServiceInfosRequest>;
+export interface PutXdslSpareServiceInfosResponse {
+}
+export declare const PutXdslSpareServiceInfosResponse: S.Schema<PutXdslSpareServiceInfosResponse>;
+export interface RebootModemRequest {
+    /** Service name */
+    serviceName: string;
+    /** Date when the reboot will start */
+    todoDate?: string;
+}
+export declare const RebootModemRequest: S.Schema<RebootModemRequest>;
+export interface RefreshXdslModemConnectedDevicesRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const RefreshXdslModemConnectedDevicesRequest: S.Schema<RefreshXdslModemConnectedDevicesRequest>;
+export interface RemoveDHCPStaticAddressRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+    /** macaddress */
+    MACAddress: string;
+}
+export declare const RemoveDHCPStaticAddressRequest: S.Schema<RemoveDHCPStaticAddressRequest>;
+export interface RemoveMonitoringNotificationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const RemoveMonitoringNotificationRequest: S.Schema<RemoveMonitoringNotificationRequest>;
+export interface RemoveMonitoringNotificationResponse {
+}
+export declare const RemoveMonitoringNotificationResponse: S.Schema<RemoveMonitoringNotificationResponse>;
+export interface RemovePortMappingRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name */
+    name: string;
+}
+export declare const RemovePortMappingRequest: S.Schema<RemovePortMappingRequest>;
+export interface ReplaceAccessModemRequest {
+    /** Service name */
+    serviceName: string;
+    /** Customer identifier for shipping address. By default Internet access address will be used. Allowed values are nichandle or «/me/contact/xyz» */
+    contactShipping?: string;
+}
+export declare const ReplaceAccessModemRequest: S.Schema<ReplaceAccessModemRequest>;
+/** A contract */
+export interface OrderContract {
+    /** Terms of the contract */
+    content?: string;
+    /** Name of the contract */
+    name?: string;
+    /** URL to download the contract */
+    url?: string;
+}
+export declare const OrderContract: S.Schema<OrderContract>;
+/** List of contracts related to the order */
+export type OrderOrderContractsList = Array<OrderContract>;
+export declare const OrderOrderContractsList: S.Schema<OrderOrderContractsList>;
+/** Product type of item in order */
+export type OrderOrderDetailTypeEnum = "ACCESSORY" | "CAUTION" | "CHOOSED" | "CONSUMPTION" | "CREATION" | "DELIVERY" | "DURATION" | "GIFT" | "INSTALLATION" | "LICENSE" | "MUTE" | "OTHER" | "OUTPLAN" | "QUANTITY" | "REFUND" | "RENEW" | "SPECIAL" | "SWITCH" | "TRANSFER" | "VOUCHER";
+export declare const OrderOrderDetailTypeEnum: any;
+/** Context of the reduction */
+export type OrderReductionContextEnum = "promotion" | "voucher";
+export declare const OrderReductionContextEnum: any;
+/** Type of reduction */
+export type OrderReductionTypeEnum = "fixed_amount" | "forced_amount" | "percentage";
+export declare const OrderReductionTypeEnum: any;
+/** Order detail reduction */
+export interface OrderReduction {
+    /** In which context the reduction is applied */
+    context?: OrderReductionContextEnum;
+    /** Promotion description */
+    description?: string;
+    /** Reduction price applied with this promotion */
+    price?: OrderPrice;
+    /** Reduction description */
+    reductionDescription?: string;
+    /** Reduction effect, price modification */
+    type?: OrderReductionTypeEnum;
+    /** The reduction value */
+    value?: OrderPrice;
+}
+export declare const OrderReduction: S.Schema<OrderReduction>;
+/** List of reductions applied to the detail */
+export type OrderOrderDetailReductionsList = Array<OrderReduction>;
+export declare const OrderOrderDetailReductionsList: S.Schema<OrderOrderDetailReductionsList>;
+/** Detail of an order */
+export interface OrderOrderDetail {
+    /** Cart Item ID the details is related to */
+    cartItemID?: number | null;
+    /** Description of the detail */
+    description?: string;
+    /** Type of detail */
+    detailType?: OrderOrderDetailTypeEnum | null;
+    /** Service name */
+    domain?: string;
+    /** Original price of the detail before reduction application */
+    originalTotalPrice?: OrderPrice;
+    /** Quantity of the service */
+    quantity?: number;
+    /** Total price of the reduction */
+    reductionTotalPrice?: OrderPrice;
+    /** List of reductions applied to the detail */
+    reductions?: OrderOrderDetailReductionsList;
+    /** Price total of the services */
+    totalPrice?: OrderPrice;
+    /** Unitary price of the service */
+    unitPrice?: OrderPrice;
+}
+export declare const OrderOrderDetail: S.Schema<OrderOrderDetail>;
+/** Details of the order */
+export type OrderOrderDetailsList = Array<OrderOrderDetail>;
+export declare const OrderOrderDetailsList: S.Schema<OrderOrderDetailsList>;
+/** Prices of an order */
+export interface OrderOrderPrices {
+    /** Price before reduction application */
+    originalWithoutTax?: OrderPrice | null;
+    /** Price concerning the reduced amount */
+    reduction?: OrderPrice | null;
+    /** Tax amount */
+    tax?: OrderPrice;
+    /** Price with tax */
+    withTax?: OrderPrice;
+    /** Price without tax */
+    withoutTax?: OrderPrice;
+}
+export declare const OrderOrderPrices: S.Schema<OrderOrderPrices>;
+/** An order */
+export interface OrderOrder {
+    /** List of contracts related to the order */
+    contracts?: OrderOrderContractsList;
+    /** Details of the order */
+    details?: OrderOrderDetailsList;
+    /** Identifier of the order */
+    orderId?: number | null;
+    /** Prices of the order including with and without taxes */
+    prices?: OrderOrderPrices;
+    /** URL to download the order */
+    url?: string | null;
+}
+export declare const OrderOrder: S.Schema<OrderOrder>;
+export interface ReplaceModemBySpareRequest {
+    /** Spare */
+    spare: string;
+    /** The modem to replace by the spare */
+    domain: string;
+}
+export declare const ReplaceModemBySpareRequest: S.Schema<ReplaceModemBySpareRequest>;
+export interface ReplaceModemBySpareResponse {
+}
+export declare const ReplaceModemBySpareResponse: S.Schema<ReplaceModemBySpareResponse>;
+export interface RequestTotalDeconsolidationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Do not port the number */
+    noPortability?: boolean;
+    /** A token to prove the ownership of the line number, needed to port the number */
+    rio?: string;
+}
+export declare const RequestTotalDeconsolidationRequest: S.Schema<RequestTotalDeconsolidationRequest>;
+export interface ResetModemConfigurationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Reset configuration stored in OVH databases */
+    resetOvhConfig?: boolean;
+}
+export declare const ResetModemConfigurationRequest: S.Schema<ResetModemConfigurationRequest>;
+export interface ResetXdslLinesDslamPortRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+}
+export declare const ResetXdslLinesDslamPortRequest: S.Schema<ResetXdslLinesDslamPortRequest>;
+export interface ResetXdslModemPortMappingConfigRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ResetXdslModemPortMappingConfigRequest: S.Schema<ResetXdslModemPortMappingConfigRequest>;
+export interface ResetXdslModemPortMappingConfigResponse {
+}
+export declare const ResetXdslModemPortMappingConfigResponse: S.Schema<ResetXdslModemPortMappingConfigResponse>;
+/** Information about the reason for the resiliation */
+export type XdslResiliationSurveyInput = IamResourceTagFilterInput;
+export declare const XdslResiliationSurveyInput: S.Schema<IamResourceTagFilterInput>;
+export interface ResiliateAccessRequest {
+    /** Service name */
+    serviceName: string;
+    /** The desired resiliation date */
+    resiliationDate?: string;
+    /** Information about the reason for the resiliation */
+    resiliationSurvey: IamResourceTagFilterInput;
+}
+export declare const ResiliateAccessRequest: S.Schema<ResiliateAccessRequest>;
+export interface SearchXdslOrderMeetingsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const SearchXdslOrderMeetingsRequest: S.Schema<SearchXdslOrderMeetingsRequest>;
+/** Represents meeting booking options */
+export interface ConnectivityEligibilityMeetingCapacities {
+    /** Whether or not it is possible to book a meeting online */
+    eRdv?: boolean;
+    /** Whether or not it is possible to be be called by phone to book a meeting */
+    phoneCall?: boolean;
+}
+export declare const ConnectivityEligibilityMeetingCapacities: S.Schema<ConnectivityEligibilityMeetingCapacities>;
+/** Represents a time slot for a meeting */
+export interface ConnectivityEligibilityMeetingSlot {
+    /** End date */
+    endDate?: string;
+    /** Represent a meeting id for a fiber collect operator */
+    slotId?: string | null;
+    /** Start date */
+    startDate?: string;
+    /** An opaque string that represents an intervention unit */
+    uiCode?: string | null;
+}
+export declare const ConnectivityEligibilityMeetingSlot: S.Schema<ConnectivityEligibilityMeetingSlot>;
+/** A time slot */
+export type ConnectivityEligibilityMeetingsMeetingSlotsList = Array<ConnectivityEligibilityMeetingSlot>;
+export declare const ConnectivityEligibilityMeetingsMeetingSlotsList: S.Schema<ConnectivityEligibilityMeetingsMeetingSlotsList>;
+/** List of available meeting time slots */
+export interface ConnectivityEligibilityMeetings {
+    /** Whether or not it is possible to book a fake meeting */
+    canBookFakeMeeting?: boolean;
+    /** Represents meeting booking options */
+    capacities?: ConnectivityEligibilityMeetingCapacities;
+    /** A time slot */
+    meetingSlots?: ConnectivityEligibilityMeetingsMeetingSlotsList;
+}
+export declare const ConnectivityEligibilityMeetings: S.Schema<ConnectivityEligibilityMeetings>;
+/** xdsl.AsyncTask_connectivity.eligibility.Meetings */
+export interface XdslAsyncTaskConnectivityEligibilityMeetings {
+    error?: string | null;
+    /** List of available meeting time slots */
+    result?: ConnectivityEligibilityMeetings;
+    /** AsyncTask status */
+    status?: XdslAsyncTaskStatusEnum;
+}
+export declare const XdslAsyncTaskConnectivityEligibilityMeetings: S.Schema<XdslAsyncTaskConnectivityEligibilityMeetings>;
+export interface SendXdslOrderToProviderRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const SendXdslOrderToProviderRequest: S.Schema<SendXdslOrderToProviderRequest>;
+export interface SendXdslOrderToProviderResponse {
+}
+export declare const SendXdslOrderToProviderResponse: S.Schema<SendXdslOrderToProviderResponse>;
+export interface SetWifiMeshStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the mesh */
+    wifiMesh: XdslServiceStatusEnum | (string & {});
+}
+export declare const SetWifiMeshStatusRequest: S.Schema<SetWifiMeshStatusRequest>;
+export interface SetWifiOneSsidStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the onessid */
+    wifiOneSsid: XdslServiceStatusEnum | (string & {});
+}
+export declare const SetWifiOneSsidStatusRequest: S.Schema<SetWifiOneSsidStatusRequest>;
+export interface UpdateBlocIPStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    status: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateBlocIPStatusRequest: S.Schema<UpdateBlocIPStatusRequest>;
+export interface UpdateContentSharingStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    contentSharing: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateContentSharingStatusRequest: S.Schema<UpdateContentSharingStatusRequest>;
+export interface UpdateDHCPStaticAddressRequest {
+    /** Service name */
+    serviceName: string;
+    /** Lan name */
+    lanName: string;
+    /** Dhcp name */
+    dhcpName: string;
+    /** macaddress */
+    MACAddress: string;
+    /** IP address (e.g., 192.0.2.0) */
+    IPAddress?: string;
+    /** Name of the DHCP Static lease */
+    name?: string | null;
+}
+export declare const UpdateDHCPStaticAddressRequest: S.Schema<UpdateDHCPStaticAddressRequest>;
+export interface UpdateDHCPStaticAddressResponse {
+}
+export declare const UpdateDHCPStaticAddressResponse: S.Schema<UpdateDHCPStaticAddressResponse>;
+export interface UpdateFTPStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    ftp: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateFTPStatusRequest: S.Schema<UpdateFTPStatusRequest>;
+export interface UpdateIpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Should the IPv6 be enabled ? */
+    enabled: boolean;
+}
+export declare const UpdateIpRequest: S.Schema<UpdateIpRequest>;
+export interface UpdateIpsecAlgStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    ipsecAlg: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateIpsecAlgStatusRequest: S.Schema<UpdateIpsecAlgStatusRequest>;
+/** Customer possible actions */
+export type XdslLineDiagnosticCustomerActionsEnum = "bePreparedToCheckModemSynchronization" | "changeDslFilterAndPlugInDti" | "changeExtensionCable" | "changeProfile" | "checkConnectionCable" | "checkConnectionLoginAndParameters" | "checkFilter" | "connectModemToOtherPlugs" | "neutralTest" | "rebootModem" | "resetModem" | "unplugEveryModems" | "unplugModem";
+export declare const XdslLineDiagnosticCustomerActionsEnum: any;
+/** Customer possible actions */
+export type UpdateLineDiagnosticRequestActionsDoneList = Array<XdslLineDiagnosticCustomerActionsEnum | (string & {})>;
+export declare const UpdateLineDiagnosticRequestActionsDoneList: S.Schema<UpdateLineDiagnosticRequestActionsDoneList>;
+/** Customer answers for line diagnostic */
+export type XdslLineDiagnosticAnswersInput = IamResourceTagFilterInput;
+export declare const XdslLineDiagnosticAnswersInput: S.Schema<IamResourceTagFilterInput>;
+/** Line diagnostic fault type */
+export type XdslLineDiagnosticFaultTypeEnum = "alignment" | "noSync" | "syncLossOrLowBandwidth" | "unknown";
+export declare const XdslLineDiagnosticFaultTypeEnum: any;
+export interface UpdateLineDiagnosticRequest {
+    /** Service name */
+    serviceName: string;
+    /** Number */
+    number: string;
+    /** Customer possible actions */
+    actionsDone?: UpdateLineDiagnosticRequestActionsDoneList;
+    /** Customer answers for line diagnostic */
+    answers?: IamResourceTagFilterInput;
+    /** Line diagnostic fault type */
+    faultType: XdslLineDiagnosticFaultTypeEnum | (string & {});
+}
+export declare const UpdateLineDiagnosticRequest: S.Schema<UpdateLineDiagnosticRequest>;
+/** List of actions already done by customer */
+export type XdslLineDiagnosticDiagnosticDataActionsDoneList = Array<XdslLineDiagnosticCustomerActionsEnum>;
+export declare const XdslLineDiagnosticDiagnosticDataActionsDoneList: S.Schema<XdslLineDiagnosticDiagnosticDataActionsDoneList>;
+/** Customer action to do */
+export interface XdslLineDiagnosticCustomerActionToDo {
+    /** action's description */
+    description?: string;
+    /** Customer possible actions */
+    name?: XdslLineDiagnosticCustomerActionsEnum;
+}
+export declare const XdslLineDiagnosticCustomerActionToDo: S.Schema<XdslLineDiagnosticCustomerActionToDo>;
+/** List of actions that must be done by customer */
+export type XdslLineDiagnosticDiagnosticDataActionsToDoList = Array<XdslLineDiagnosticCustomerActionToDo>;
+export declare const XdslLineDiagnosticDiagnosticDataActionsToDoList: S.Schema<XdslLineDiagnosticDiagnosticDataActionsToDoList>;
+/** bandwidth unit for proof.ovh.net test values */
+export type XdslLineDiagnosticBandwidthTestUnitEnum = "Kbps" | "Mbps";
+export declare const XdslLineDiagnosticBandwidthTestUnitEnum: any;
+/** Possible customer questions */
+export type XdslLineDiagnosticProblemTypeEnum = "lowBandwidth" | "syncLoss";
+export declare const XdslLineDiagnosticProblemTypeEnum: any;
+/** Customer answers for line diagnostic */
+export interface XdslLineDiagnosticAnswers {
+    /** bandwidth unit for proof.ovh.net test values */
+    bandwidthTestUnit?: XdslLineDiagnosticBandwidthTestUnitEnum | null;
+    /** comment will contains all information needed for intervention and about your access problem */
+    comment?: string | null;
+    /** customer knows that he can be charged (150 euros HT) if he is responsible for the problem or if tests have not been done correctly ? */
+    conditionsAccepted?: boolean | null;
+    /** customer's phone number */
+    contactPhone?: string | null;
+    /** approximative datetime of problem happening */
+    datetimeOfAppearance?: string | null;
+    /** bandwidth download value on proof.ovh.net test */
+    downloadBandwidthTest?: number | null;
+    /** afternoon closing information or time for the site */
+    endAfternoonHours?: string | null;
+    /** morning closing information or time for the site */
+    endMorningHours?: string | null;
+    /** indicate if customer wants to be informed by sms */
+    followBySms?: boolean | null;
+    /** Has modem kept his synchronization during line port reset ? */
+    hasModemKeptSynchronization?: boolean | null;
+    /** id of appointment chosen ("possibleValues" contains choices list with id) */
+    idAppointment?: number | null;
+    /** is non-professional site ? */
+    individualSite?: boolean | null;
+    /** Is modem synchronized ? (whatever internet connection) */
+    modemIsSynchronized?: boolean | null;
+    /** modem mac address */
+    modemMac?: string | null;
+    /** Modem still synchronized ? Please check once again. */
+    modemStillSynchronized?: boolean | null;
+    /** modem brand and reference */
+    modemType?: string | null;
+    /** Ovh ticket name or ticket ID, only if a ticket is already opened for this problem */
+    ovhTicket?: string | null;
+    /** Problem Type on DSL connection */
+    problemType?: XdslLineDiagnosticProblemTypeEnum | null;
+    /** is access problem solved ? */
+    resolvedAfterTests?: boolean | null;
+    /** is secure site ? */
+    secureSite?: boolean | null;
+    /** Has customer several internal connections ? (on the same place) */
+    severalInternetConnections?: boolean | null;
+    /** days or period where site access is not possible */
+    siteClosedDays?: string | null;
+    /** digicode for site entrance */
+    siteDigicode?: string | null;
+    /** site opening hours or information */
+    siteOpening?: string | null;
+    /** afternoon opening information or time for the site */
+    startAfternoonHours?: string | null;
+    /** morning opening information or time for the site */
+    startMorningHours?: string | null;
+    /** bandwidth upload value on proof.ovh.net test */
+    uploadBandwidthTest?: number | null;
+}
+export declare const XdslLineDiagnosticAnswers: S.Schema<XdslLineDiagnosticAnswers>;
+/** Informations directly get on DSLAM or Modem */
+export interface XdslLineDiagnosticConnectionInformations {
+    /** Amount of CRC error detected */
+    crcError?: number | null;
+    /** Downstream attenuation */
+    downstreamAttenuation?: number | null;
+    /** Downstream margin */
+    downstreamMargin?: number | null;
+    /** Downstream synchronization */
+    downstreamSync?: number | null;
+    /** Modem interface name */
+    ifName?: string | null;
+    /** Profile on the DSLAM */
+    profile?: string | null;
+    /** Upstream attenuation */
+    upstreamAttenuation?: number | null;
+    /** Upstream margin */
+    upstreamMargin?: number | null;
+    /** Upstream synchronization */
+    upstreamSync?: number | null;
+}
+export declare const XdslLineDiagnosticConnectionInformations: S.Schema<XdslLineDiagnosticConnectionInformations>;
+/** Theoretical line capabilities */
+export interface XdslLineDiagnosticLineCapabilities {
+    /** Theoretical Downstream synchronization */
+    down?: number | null;
+    /** Theoretical line mitigation */
+    mitigation?: string | null;
+    /** Theoretical ping */
+    ping?: number | null;
+    /** Theoretical Upstream synchronization */
+    up?: number | null;
+}
+export declare const XdslLineDiagnosticLineCapabilities: S.Schema<XdslLineDiagnosticLineCapabilities>;
+/** Cables section details */
+export interface XdslLineDiagnosticSection {
+    /** cables length in meters */
+    length?: number;
+    /** cables section in millimeters */
+    section?: number;
+}
+export declare const XdslLineDiagnosticSection: S.Schema<XdslLineDiagnosticSection>;
+/** cables sections details */
+export type XdslLineDiagnosticLineDetailsSectionsList = Array<XdslLineDiagnosticSection>;
+export declare const XdslLineDiagnosticLineDetailsSectionsList: S.Schema<XdslLineDiagnosticLineDetailsSectionsList>;
+/** Line information */
+export interface XdslLineDiagnosticLineDetails {
+    /** access name */
+    accessName?: string;
+    /** Access IP ping or not */
+    accessPing?: boolean | null;
+    /** address of the access */
+    address?: string | null;
+    /** information directly get on DSLAM or Modem */
+    connectionInfo?: XdslLineDiagnosticConnectionInformations | null;
+    /** customer phone number for contact */
+    contactPhone?: string | null;
+    /** custom access description */
+    description?: string | null;
+    /** DSLAM is synchronized or not */
+    dslamIsSynchronized?: boolean | null;
+    /** is GTR access or not */
+    gtr?: boolean;
+    /** Line length in meters */
+    length?: number;
+    /** Theoretical line capabilities */
+    lineCapabilities?: XdslLineDiagnosticLineCapabilities | null;
+    /** Possible DSL technologies */
+    lineType?: XdslDslTypeEnum;
+    /** NRA name */
+    nra?: string | null;
+    /** line number */
+    number?: string;
+    /** The providers */
+    operator?: XdslProviderEnum;
+    /** cables sections details */
+    sections?: XdslLineDiagnosticLineDetailsSectionsList | null;
+}
+export declare const XdslLineDiagnosticLineDetails: S.Schema<XdslLineDiagnosticLineDetails>;
+/** Diagnostic robot possible actions */
+export type XdslLineDiagnosticRobotActionsEnum = "alignmentLockTest" | "alignmentResetTest" | "alignmentTestResult" | "checkCustomerTicket" | "checkIfAccessPing" | "checkIfResolvedAfterConnectionTests" | "checkIfResolvedAfterInstallationCheck" | "checkIfResolvedAfterTests" | "checkIfSeveralConnections" | "checkInstallation" | "checkProblem" | "checkSynchronizationWithoutOtherModems" | "customerPrelocChecks" | "findProblem" | "installationCheck" | "lockUnlock" | "needToRequestMonitoring" | "needToRequestOperatorIntervention" | "needToRequestOvhIntervention" | "requestMonitoring" | "requestOperatorIntervention" | "requestOvhIntervention" | "seltTest";
+export declare const XdslLineDiagnosticRobotActionsEnum: any;
+/** Possible SELT test prelocalizations */
+export type XdslLineDiagnosticSeltPrelocEnum = "CUST" | "DSLAM" | "LINE" | "RE";
+export declare const XdslLineDiagnosticSeltPrelocEnum: any;
+/** Possible SELT test states */
+export type XdslLineDiagnosticSeltStateEnum = "open" | "short" | "synced" | "unknown";
+export declare const XdslLineDiagnosticSeltStateEnum: any;
+/** Possible SELT test status */
+export type XdslLineDiagnosticSeltStatusEnum = "failed" | "notAvailable" | "ok";
+export declare const XdslLineDiagnosticSeltStatusEnum: any;
+/** Customer answers for line diagnostic */
+export interface XdslLineDiagnosticSeltResult {
+    /** SELT test running date */
+    date?: string | null;
+    /** Distance of the problem identified on the line (by SELT test), from NRA to customer */
+    distance?: number | null;
+    /** Prelocalization of the problem */
+    preloc?: XdslLineDiagnosticSeltPrelocEnum | null;
+    /** Problem type identified by SELT test */
+    state?: XdslLineDiagnosticSeltStateEnum | null;
+    /** SELT test status */
+    status?: XdslLineDiagnosticSeltStatusEnum | null;
+}
+export declare const XdslLineDiagnosticSeltResult: S.Schema<XdslLineDiagnosticSeltResult>;
+/** available values for enum */
+export type XdslLineDiagnosticQuestionEnumValuesList = Array<string>;
+export declare const XdslLineDiagnosticQuestionEnumValuesList: S.Schema<XdslLineDiagnosticQuestionEnumValuesList>;
+/** Possible customer questions */
+export type XdslLineDiagnosticQuestionsEnum = "bandwidthTestUnit" | "comment" | "conditionsAccepted" | "contactPhone" | "datetimeOfAppearance" | "downloadBandwidthTest" | "endAfternoonHours" | "endMorningHours" | "followBySms" | "hasModemKeptSynchronization" | "idAppointment" | "individualSite" | "modemIsSynchronized" | "modemMac" | "modemStillSynchronized" | "modemType" | "ovhTicket" | "problemType" | "resolvedAfterTests" | "secureSite" | "severalInternetConnections" | "siteClosedDays" | "siteDigicode" | "siteOpening" | "startAfternoonHours" | "startMorningHours" | "uploadBandwidthTest";
+export declare const XdslLineDiagnosticQuestionsEnum: any;
+/** possible value for specific answer */
+export interface XdslLineDiagnosticPossibleValue {
+    /** answer id */
+    id?: number | null;
+    /** answer choice string */
+    label?: string | null;
+    /** answer choice value */
+    value?: string | null;
+}
+export declare const XdslLineDiagnosticPossibleValue: S.Schema<XdslLineDiagnosticPossibleValue>;
+/** list of possible values */
+export type XdslLineDiagnosticQuestionPossibleValuesList = Array<XdslLineDiagnosticPossibleValue>;
+export declare const XdslLineDiagnosticQuestionPossibleValuesList: S.Schema<XdslLineDiagnosticQuestionPossibleValuesList>;
+/** Question to customer */
+export interface XdslLineDiagnosticQuestion {
+    /** question description */
+    defaultValue?: string | null;
+    /** question description */
+    description?: string;
+    /** available values for enum */
+    enumValues?: XdslLineDiagnosticQuestionEnumValuesList | null;
+    /** Possible customer questions */
+    name?: XdslLineDiagnosticQuestionsEnum;
+    /** list of possible values */
+    possibleValues?: XdslLineDiagnosticQuestionPossibleValuesList | null;
+    /** is a required question */
+    required?: boolean | null;
+    /** answer type */
+    type?: string;
+}
+export declare const XdslLineDiagnosticQuestion: S.Schema<XdslLineDiagnosticQuestion>;
+/** List of questions that must be answered by customer */
+export type XdslLineDiagnosticDiagnosticDataToAnswerList = Array<XdslLineDiagnosticQuestion>;
+export declare const XdslLineDiagnosticDiagnosticDataToAnswerList: S.Schema<XdslLineDiagnosticDiagnosticDataToAnswerList>;
+/** Diagnostic data and information */
+export interface XdslLineDiagnosticDiagnosticData {
+    /** List of actions already done by customer */
+    actionsDone?: XdslLineDiagnosticDiagnosticDataActionsDoneList;
+    /** List of actions that must be done by customer */
+    actionsToDo?: XdslLineDiagnosticDiagnosticDataActionsToDoList;
+    /** Customer answers for line diagnostic */
+    answers?: XdslLineDiagnosticAnswers;
+    /** Diagnostic comment. Can be update during any diagnostic step */
+    comment?: string | null;
+    /** Diagnostic creation date */
+    creationDate?: string;
+    /** End of diagnostic date. Will be null until problem totally identified */
+    diagnosticDoneDate?: string | null;
+    /** Error message */
+    error?: string;
+    /** Last diagnostic update date */
+    lastUpdate?: string;
+    /** Line information */
+    lineDetails?: XdslLineDiagnosticLineDetails;
+    /** Current or last robot action */
+    robotAction?: XdslLineDiagnosticRobotActionsEnum | null;
+    /** Customer answers for line diagnostic */
+    seltTest?: XdslLineDiagnosticSeltResult;
+    /** Diagnostic timeout in minutes. Any action restart timeout */
+    timeout?: number;
+    /** List of questions that must be answered by customer */
+    toAnswer?: XdslLineDiagnosticDiagnosticDataToAnswerList;
+}
+export declare const XdslLineDiagnosticDiagnosticData: S.Schema<XdslLineDiagnosticDiagnosticData>;
+/** Diagnostic status possible values */
+export type XdslLineDiagnosticDiagnosticStatusEnum = "cancelled" | "connectionProblem" | "genericIncidentPending" | "haveToConnectModemOnTheRightPlug" | "init" | "interventionRequested" | "noBandwidthFault" | "noProblemAnymore" | "noSyncFaultDiagnosticRequired" | "problem" | "resolvedAfterTests" | "sleeping" | "validationRefused" | "waitingHuman" | "waitingRobot" | "waitingValidation";
+export declare const XdslLineDiagnosticDiagnosticStatusEnum: any;
+/** Diagnostic status and information */
+export interface XdslLineDiagnosticDiagnostic {
+    /** Diagnostic data and information */
+    data?: XdslLineDiagnosticDiagnosticData;
+    /** Line diagnostic fault type */
+    faultType?: XdslLineDiagnosticFaultTypeEnum;
+    /** Diagnostic id */
+    id?: number;
+    /** Diagnostic status possible values */
+    status?: XdslLineDiagnosticDiagnosticStatusEnum;
+}
+export declare const XdslLineDiagnosticDiagnostic: S.Schema<XdslLineDiagnosticDiagnostic>;
+/** Status allowed for mail sending */
+export type XdslMailSendingStatusEnum = "disabled" | "enabled";
+export declare const XdslMailSendingStatusEnum: any;
+export interface UpdateMailSendingRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status allowed for mail sending */
+    status: XdslMailSendingStatusEnum | (string & {});
+}
+export declare const UpdateMailSendingRequest: S.Schema<UpdateMailSendingRequest>;
+export interface UpdateModemCallWaitingRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    callWaiting: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateModemCallWaitingRequest: S.Schema<UpdateModemCallWaitingRequest>;
+export interface UpdateModemTemplateRequest {
+    /** Name */
+    name: string;
+    /** Do not apply these parameters from template. You can use parametersCapabilities to know availability */
+    parametersToIgnore?: XdslTemplateModemParametersToIgnore | null;
+}
+export declare const UpdateModemTemplateRequest: S.Schema<UpdateModemTemplateRequest>;
+export interface UpdateModemTemplateResponse {
+}
+export declare const UpdateModemTemplateResponse: S.Schema<UpdateModemTemplateResponse>;
+export interface UpdateMonitoringNotificationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+    /** Whether or not to allow notifications for generic incidents */
+    allowIncident?: boolean;
+    /** The number of seconds the access has to be down to trigger an alert */
+    downThreshold?: number;
+    /** The e-mail address, if type is mail */
+    email?: string | null;
+    /** Whether to enable or not */
+    enabled?: boolean;
+    /** Frequency between notifications. */
+    frequency?: XdslMonitoringNotificationsFrequencyEnum | (string & {});
+    /** The phone number, if type is sms */
+    phone?: string | null;
+}
+export declare const UpdateMonitoringNotificationRequest: S.Schema<UpdateMonitoringNotificationRequest>;
+export interface UpdateMonitoringNotificationResponse {
+}
+export declare const UpdateMonitoringNotificationResponse: S.Schema<UpdateMonitoringNotificationResponse>;
+export interface UpdatePortMappingRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name */
+    name: string;
+    /** An ip which will access to the defined rule. Default : no restriction applied */
+    allowedRemoteIp?: string | null;
+    /** Description of the Port Mapping */
+    description?: string | null;
+    /** The last port of the interval on the External Client that will get the connections */
+    externalPortEnd?: number | null;
+    /** External Port that the modem will listen on. List of externalPorts not available for now in the API : 8, 21, 68, 5060, 21800-21805, 51005 */
+    externalPortStart?: number;
+    /** IP address (e.g., 192.0.2.0) */
+    internalClient?: string;
+    /** The port on the Internal Client that will get the connections */
+    internalPort?: number;
+    /** The last port of the interval on the Internal Client that will get the connections */
+    internalPortEnd?: number | null;
+    /** Type of protocol for the Port Mapping */
+    protocol?: XdslXdslModemConfigProtocolTypeEnum | (string & {});
+}
+export declare const UpdatePortMappingRequest: S.Schema<UpdatePortMappingRequest>;
+export interface UpdatePortMappingResponse {
+}
+export declare const UpdatePortMappingResponse: S.Schema<UpdatePortMappingResponse>;
+export interface UpdateRIORequest {
+    /** Service name */
+    serviceName: string;
+    /** Do not set RIO, and relaunch order without portability */
+    relaunchWithoutPortability: boolean;
+    /** RIO number for portability */
+    rio?: string;
+}
+export declare const UpdateRIORequest: S.Schema<UpdateRIORequest>;
+export interface UpdateRIOResponse {
+}
+export declare const UpdateRIOResponse: S.Schema<UpdateRIOResponse>;
+/** Types of return merchandise authorisation you can change to */
+export type TelephonyRmaChangeTypeEnum = "resiliate" | "toSip";
+export declare const TelephonyRmaChangeTypeEnum: any;
+export interface UpdateRMATypeRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: string;
+    /** Types of return merchandise authorisation you can change to */
+    type: TelephonyRmaChangeTypeEnum | (string & {});
+}
+export declare const UpdateRMATypeRequest: S.Schema<UpdateRMATypeRequest>;
+export interface UpdateRMATypeResponse {
+}
+export declare const UpdateRMATypeResponse: S.Schema<UpdateRMATypeResponse>;
+export interface UpdateSipAlgStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    sipAlg: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateSipAlgStatusRequest: S.Schema<UpdateSipAlgStatusRequest>;
+export interface UpdateUpnpStatusRequest {
+    /** Service name */
+    serviceName: string;
+    /** Status of the service */
+    upnp: XdslServiceStatusEnum | (string & {});
+}
+export declare const UpdateUpnpStatusRequest: S.Schema<UpdateUpnpStatusRequest>;
+export type AddDHCPStaticAddressError = OvhOpError;
+/** Add a DHCP static lease */
+export declare const addDHCPStaticAddress: API.OperationMethod<AddDHCPStaticAddressRequest, XdslDHCPStaticAddress, AddDHCPStaticAddressError, OvhOpContext>;
+export type AddMonitoringNotificationError = OvhOpError;
+/** Add a notification */
+export declare const addMonitoringNotification: API.OperationMethod<AddMonitoringNotificationRequest, XdslMonitoringNotification, AddMonitoringNotificationError, OvhOpContext>;
+export type AddPortMappingError = OvhOpError;
+/** Add a port mapping */
+export declare const addPortMapping: API.OperationMethod<AddPortMappingRequest, XdslPortMapping, AddPortMappingError, OvhOpContext>;
+export type ApplyTemplateModemError = OvhOpError;
+/** Apply TemplateModem to existing Modem */
+export declare const applyTemplateModem: API.OperationMethod<ApplyTemplateModemRequest, XdslTask, ApplyTemplateModemError, OvhOpContext>;
+export type ArchiveXdslTaskError = OvhOpError;
+/** Delete the task in problem from the results */
+export declare const archiveXdslTask: API.OperationMethod<ArchiveXdslTaskRequest, ArchiveXdslTaskResponse, ArchiveXdslTaskError, OvhOpContext>;
+export type BookMeetingError = OvhOpError;
+/** Book a meeting and relaunch order */
+export declare const bookMeeting: API.OperationMethod<BookMeetingRequest, BookMeetingResponse, BookMeetingError, OvhOpContext>;
+export type CancelXdslLinesDiagnosticError = OvhOpError;
+/** Cancel line diagnostic if possible */
+export declare const cancelXdslLinesDiagnostic: API.OperationMethod<CancelXdslLinesDiagnosticRequest, CancelXdslLinesDiagnosticResponse, CancelXdslLinesDiagnosticError, OvhOpContext>;
+export type CancelXdslResiliationError = OvhOpError;
+/** Cancel the ongoing resiliation */
+export declare const cancelXdslResiliation: API.OperationMethod<CancelXdslResiliationRequest, CancelXdslResiliationResponse, CancelXdslResiliationError, OvhOpContext>;
+export type ChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const changeContact: API.OperationMethod<ChangeContactRequest, ChangeContactResponse, ChangeContactError, OvhOpContext>;
+export type ChangeEmailPasswordError = OvhOpError;
+/** Change the email password */
+export declare const changeEmailPassword: API.OperationMethod<ChangeEmailPasswordRequest, XdslEmailProTask, ChangeEmailPasswordError, OvhOpContext>;
+export type ChangeLineDSLAMProfileError = OvhOpError;
+/** Change the profile of the port */
+export declare const changeLineDSLAMProfile: API.OperationMethod<ChangeLineDSLAMProfileRequest, XdslTask, ChangeLineDSLAMProfileError, OvhOpContext>;
+export type CreateModemTemplateError = OvhOpError;
+/** Create new Modem Template from existing modem */
+export declare const createModemTemplate: API.OperationMethod<CreateModemTemplateRequest, XdslTemplateModem, CreateModemTemplateError, OvhOpContext>;
+export type CreateXdslAddressMoveExtraIpRangeMoveError = OvhOpError;
+/** Initiate the extra IP range migration */
+export declare const createXdslAddressMoveExtraIpRangeMove: API.OperationMethod<CreateXdslAddressMoveExtraIpRangeMoveRequest, XdslTask, CreateXdslAddressMoveExtraIpRangeMoveError, OvhOpContext>;
+export type CreateXdslDiagnosticError = OvhOpError;
+/** Run diagnostic on the access */
+export declare const createXdslDiagnostic: API.OperationMethod<CreateXdslDiagnosticRequest, XdslTask, CreateXdslDiagnosticError, OvhOpContext>;
+export type CreateXdslIpsError = OvhOpError;
+/** Order an extra /29 range of IPv4 addresses */
+export declare const createXdslIps: API.OperationMethod<CreateXdslIpsRequest, XdslTask, CreateXdslIpsError, OvhOpContext>;
+export type CreateXdslModemReconfigureVoipError = OvhOpError;
+/** Reconfigure voip line on modem */
+export declare const createXdslModemReconfigureVoip: API.OperationMethod<CreateXdslModemReconfigureVoipRequest, CreateXdslModemReconfigureVoipResponse, CreateXdslModemReconfigureVoipError, OvhOpContext>;
+export type CreateXdslRequestPPPLoginMailError = OvhOpError;
+/** Renew PPP password and send the PPP login information to the e-mail of the nicAdmin */
+export declare const createXdslRequestPPPLoginMail: API.OperationMethod<CreateXdslRequestPPPLoginMailRequest, CreateXdslRequestPPPLoginMailResponse, CreateXdslRequestPPPLoginMailError, OvhOpContext>;
+export type CreateXdslSpareReturnMerchandiseError = OvhOpError;
+/** Return the broken equipment in instantRefund */
+export declare const createXdslSpareReturnMerchandise: API.OperationMethod<CreateXdslSpareReturnMerchandiseRequest, CreateXdslSpareReturnMerchandiseResponse, CreateXdslSpareReturnMerchandiseError, OvhOpContext>;
+export type DeleteModemTemplateError = OvhOpError;
+/** Delete this Modem Template */
+export declare const deleteModemTemplate: API.OperationMethod<DeleteModemTemplateRequest, DeleteModemTemplateResponse, DeleteModemTemplateError, OvhOpContext>;
+export type DeleteXdslEmailProError = OvhOpError;
+/** Delete the email */
+export declare const deleteXdslEmailPro: API.OperationMethod<DeleteXdslEmailProRequest, DeleteXdslEmailProResponse, DeleteXdslEmailProError, OvhOpContext>;
+export type DeleteXdslIpsError = OvhOpError;
+/** Stop renewing this extra IPv4 option */
+export declare const deleteXdslIps: API.OperationMethod<DeleteXdslIpsRequest, DeleteXdslIpsResponse, DeleteXdslIpsError, OvhOpContext>;
+export type DeleteXdslRmaError = OvhOpError;
+/** Cancel the rma */
+export declare const deleteXdslRma: API.OperationMethod<DeleteXdslRmaRequest, DeleteXdslRmaResponse, DeleteXdslRmaError, OvhOpContext>;
+export type DeleteXdslSpareError = OvhOpError;
+/** Delete the spare as if it was not belonging to OVH anymore */
+export declare const deleteXdslSpare: API.OperationMethod<DeleteXdslSpareRequest, DeleteXdslSpareResponse, DeleteXdslSpareError, OvhOpContext>;
+export type GetAccessModemReplacementError = OvhOpError;
+/** Get info about access modem replacement by last model. */
+export declare const getAccessModemReplacement: API.OperationMethod<GetAccessModemReplacementRequest, XdslModemExchangeInfo, GetAccessModemReplacementError, OvhOpContext>;
+export type GetBlocIPStatusError = OvhOpError;
+/** Get the status of the Bloc IP on modem */
+export declare const getBlocIPStatus: API.OperationMethod<GetBlocIPStatusRequest, GetBlocIPStatusResponse, GetBlocIPStatusError, OvhOpContext>;
+export type GetContentSharingStatusError = OvhOpError;
+/** Get the status of contentSharing on modem */
+export declare const getContentSharingStatus: API.OperationMethod<GetContentSharingStatusRequest, GetContentSharingStatusResponse, GetContentSharingStatusError, OvhOpContext>;
+export type GetDHCPStaticAddressError = OvhOpError;
+/** Get this object properties */
+export declare const getDHCPStaticAddress: API.OperationMethod<GetDHCPStaticAddressRequest, XdslDHCPStaticAddress, GetDHCPStaticAddressError, OvhOpContext>;
+export type GetDHCPStaticAddressesError = OvhOpError;
+/** List of DHCP Static Address of this modem */
+export declare const getDHCPStaticAddresses: API.OperationMethod<GetDHCPStaticAddressesRequest, GetDHCPStaticAddressesResponse, GetDHCPStaticAddressesError, OvhOpContext>;
+export type GetFirmwareVersionError = OvhOpError;
+/** Get the firmware version installed on modem */
+export declare const getFirmwareVersion: API.OperationMethod<GetFirmwareVersionRequest, GetFirmwareVersionResponse, GetFirmwareVersionError, OvhOpContext>;
+export type GetFTPStatusError = OvhOpError;
+/** Get the status of ftp service on modem */
+export declare const getFTPStatus: API.OperationMethod<GetFTPStatusRequest, GetFTPStatusResponse, GetFTPStatusError, OvhOpContext>;
+export type GetIpsecAlgStatusError = OvhOpError;
+/** Get the status of ipsec alg service on modem */
+export declare const getIpsecAlgStatus: API.OperationMethod<GetIpsecAlgStatusRequest, GetIpsecAlgStatusResponse, GetIpsecAlgStatusError, OvhOpContext>;
+export type GetModemCallWaitingStatusError = OvhOpError;
+/** Get the status of callWaiting on modem */
+export declare const getModemCallWaitingStatus: API.OperationMethod<GetModemCallWaitingStatusRequest, GetModemCallWaitingStatusResponse, GetModemCallWaitingStatusError, OvhOpContext>;
+export type GetModemTemplateError = OvhOpError;
+/** Get this object properties */
+export declare const getModemTemplate: API.OperationMethod<GetModemTemplateRequest, XdslTemplateModem, GetModemTemplateError, OvhOpContext>;
+export type GetModemTemplatesError = OvhOpError;
+/** List of TemplateModem */
+export declare const getModemTemplates: API.OperationMethod<GetModemTemplatesRequest, GetModemTemplatesResponse, GetModemTemplatesError, OvhOpContext>;
+export type GetMonitoringNotificationError = OvhOpError;
+/** Get this object properties */
+export declare const getMonitoringNotification: API.OperationMethod<GetMonitoringNotificationRequest, XdslMonitoringNotification, GetMonitoringNotificationError, OvhOpContext>;
+export type GetMonitoringNotificationsError = OvhOpError;
+/** List the notifications for this access */
+export declare const getMonitoringNotifications: API.OperationMethod<GetMonitoringNotificationsRequest, GetMonitoringNotificationsResponse, GetMonitoringNotificationsError, OvhOpContext>;
+export type GetPortMappingError = OvhOpError;
+/** Get this object properties */
+export declare const getPortMapping: API.OperationMethod<GetPortMappingRequest, XdslPortMapping, GetPortMappingError, OvhOpContext>;
+export type GetPortMappingsError = OvhOpError;
+/** List of PortMappings on this modem */
+export declare const getPortMappings: API.OperationMethod<GetPortMappingsRequest, GetPortMappingsResponse, GetPortMappingsError, OvhOpContext>;
+export type GetSipAlgStatusError = OvhOpError;
+/** Get the status of sip alg service on modem */
+export declare const getSipAlgStatus: API.OperationMethod<GetSipAlgStatusRequest, GetSipAlgStatusResponse, GetSipAlgStatusError, OvhOpContext>;
+export type GetUpnpStatusError = OvhOpError;
+/** Get the status of the Upnp on modem */
+export declare const getUpnpStatus: API.OperationMethod<GetUpnpStatusRequest, GetUpnpStatusResponse, GetUpnpStatusError, OvhOpContext>;
+export type GetWifiMeshStatusError = OvhOpError;
+/** Get the status of mesh on this modem */
+export declare const getWifiMeshStatus: API.OperationMethod<GetWifiMeshStatusRequest, GetWifiMeshStatusResponse, GetWifiMeshStatusError, OvhOpContext>;
+export type GetWifiOneSsidStatusError = OvhOpError;
+/** Get the status of onessid on this modem */
+export declare const getWifiOneSsidStatus: API.OperationMethod<GetWifiOneSsidStatusRequest, GetWifiOneSsidStatusResponse, GetWifiOneSsidStatusError, OvhOpContext>;
+export type GetXdslError = OvhOpError;
+/** Get this object properties */
+export declare const getXdsl: API.OperationMethod<GetXdslRequest, XdslAccessWithIAM, GetXdslError, OvhOpContext>;
+export type GetXdslAddressMoveExtraIpRangeError = OvhOpError;
+/** Informations about the extra IP range during address move */
+export declare const getXdslAddressMoveExtraIpRange: API.OperationMethod<GetXdslAddressMoveExtraIpRangeRequest, XdslExtraIpRangeMove, GetXdslAddressMoveExtraIpRangeError, OvhOpContext>;
+export type GetXdslAntiSpamError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslAntiSpam: API.OperationMethod<GetXdslAntiSpamRequest, XdslAntiSpam, GetXdslAntiSpamError, OvhOpContext>;
+export type GetXdslCanCancelResiliationError = OvhOpError;
+/** Get information about the ongoing resiliation */
+export declare const getXdslCanCancelResiliation: API.OperationMethod<GetXdslCanCancelResiliationRequest, GetXdslCanCancelResiliationResponse, GetXdslCanCancelResiliationError, OvhOpContext>;
+export type GetXdslDiagnosticError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslDiagnostic: API.OperationMethod<GetXdslDiagnosticRequest, XdslAccessDiagnostic, GetXdslDiagnosticError, OvhOpContext>;
+export type GetXdslEmailProError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslEmailPro: API.OperationMethod<GetXdslEmailProRequest, XdslXdslEmailProWithIAM, GetXdslEmailProError, OvhOpContext>;
+export type GetXdslFiberEligibilityError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslFiberEligibility: API.OperationMethod<GetXdslFiberEligibilityRequest, XdslFiberEligibility, GetXdslFiberEligibilityError, OvhOpContext>;
+export type GetXdslIncidentError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslIncident: API.OperationMethod<GetXdslIncidentRequest, XdslIncident, GetXdslIncidentError, OvhOpContext>;
+export type GetXdslIncident2Error = OvhOpError;
+/** Get this object properties */
+export declare const getXdslIncident2: API.OperationMethod<GetXdslIncidentRequest2, XdslIncident, GetXdslIncident2Error, OvhOpContext>;
+export type GetXdslIpsError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslIps: API.OperationMethod<GetXdslIpsRequest, XdslIP, GetXdslIpsError, OvhOpContext>;
+export type GetXdslLineError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslLine: API.OperationMethod<GetXdslLineRequest, XdslLine, GetXdslLineError, OvhOpContext>;
+export type GetXdslLineDslamPortError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslLineDslamPort: API.OperationMethod<GetXdslLineDslamPortRequest, XdslDslamPort, GetXdslLineDslamPortError, OvhOpContext>;
+export type GetXdslModemError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslModem: API.OperationMethod<GetXdslModemRequest, XdslModem, GetXdslModemError, OvhOpContext>;
+export type GetXdslModemConnectedDeviceError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslModemConnectedDevice: API.OperationMethod<GetXdslModemConnectedDeviceRequest, XdslConnectedDevice, GetXdslModemConnectedDeviceError, OvhOpContext>;
+export type GetXdslModemInfoError = OvhOpError;
+/** get general Modem information */
+export declare const getXdslModemInfo: API.OperationMethod<GetXdslModemInfoRequest, XdslAsyncTaskXdslModemInfo, GetXdslModemInfoError, OvhOpContext>;
+export type GetXdslModemLanError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslModemLan: API.OperationMethod<GetXdslModemLanRequest, XdslLAN, GetXdslModemLanError, OvhOpContext>;
+export type GetXdslModemLanDhcpError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslModemLanDhcp: API.OperationMethod<GetXdslModemLanDhcpRequest, XdslDHCP, GetXdslModemLanDhcpError, OvhOpContext>;
+export type GetXdslModemWifiError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslModemWifi: API.OperationMethod<GetXdslModemWifiRequest, XdslWLAN, GetXdslModemWifiError, OvhOpContext>;
+export type GetXdslModemWifiQrCodeError = OvhOpError;
+/** Get the WiFi configuration QR code as base64, if applicable */
+export declare const getXdslModemWifiQrCode: API.OperationMethod<GetXdslModemWifiQrCodeRequest, GetXdslModemWifiQrCodeResponse, GetXdslModemWifiQrCodeError, OvhOpContext>;
+export type GetXdslModemWifiRadioError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslModemWifiRadio: API.OperationMethod<GetXdslModemWifiRadioRequest, XdslWifiRadio, GetXdslModemWifiRadioError, OvhOpContext>;
+export type GetXdslOntError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslOnt: API.OperationMethod<GetXdslOntRequest, XdslOnt, GetXdslOntError, OvhOpContext>;
+export type GetXdslPendingActionError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslPendingAction: API.OperationMethod<GetXdslPendingActionRequest, XdslPendingAction, GetXdslPendingActionError, OvhOpContext>;
+export type GetXdslResiliationFollowupError = OvhOpError;
+/** Get information about the ongoing resiliation */
+export declare const getXdslResiliationFollowup: API.OperationMethod<GetXdslResiliationFollowupRequest, XdslResiliationFollowUpDetail, GetXdslResiliationFollowupError, OvhOpContext>;
+export type GetXdslResiliationTermsError = OvhOpError;
+/** Get resiliation terms */
+export declare const getXdslResiliationTerms: API.OperationMethod<GetXdslResiliationTermsRequest, XdslResiliationTerms, GetXdslResiliationTermsError, OvhOpContext>;
+export type GetXdslRmaError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslRma: API.OperationMethod<GetXdslRmaRequest, TelephonyRma, GetXdslRmaError, OvhOpContext>;
+export type GetXdslServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getXdslServiceInfos: API.OperationMethod<GetXdslServiceInfosRequest, ServicesService, GetXdslServiceInfosError, OvhOpContext>;
+export type GetXdslSpareError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslSpare: API.OperationMethod<GetXdslSpareRequest, SpareXdslXdslSpareWithIAM, GetXdslSpareError, OvhOpContext>;
+export type GetXdslSpareServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getXdslSpareServiceInfos: API.OperationMethod<GetXdslSpareServiceInfosRequest, ServicesService, GetXdslSpareServiceInfosError, OvhOpContext>;
+export type GetXdslTaskError = OvhOpError;
+/** Get this object properties */
+export declare const getXdslTask: API.OperationMethod<GetXdslTaskRequest, XdslTask, GetXdslTaskError, OvhOpContext>;
+export type GetXdslTotalDeconsolidationTermsError = OvhOpError;
+/** Give the price to requestTotalDeconsolidation on the access */
+export declare const getXdslTotalDeconsolidationTerms: API.OperationMethod<GetXdslTotalDeconsolidationTermsRequest, XdslDeconsolidationTerms, GetXdslTotalDeconsolidationTermsError, OvhOpContext>;
+export type InstallFrimwareError = OvhOpError;
+/** Launch a task to install target firmware on modem */
+export declare const installFrimware: API.OperationMethod<InstallFrimwareRequest, XdslTask, InstallFrimwareError, OvhOpContext>;
+export type ListXdslError = OvhOpError;
+/** List available services */
+export declare const listXdsl: API.OperationMethod<ListXdslRequest, ListXdslResponse, ListXdslError, OvhOpContext>;
+export type ListXdslAntiSpamEvidencesError = OvhOpError;
+/** List of evidences stored on PCS for this ip */
+export declare const listXdslAntiSpamEvidences: API.OperationMethod<ListXdslAntiSpamEvidencesRequest, XdslAntiSpamEvidencesInfo, ListXdslAntiSpamEvidencesError, OvhOpContext>;
+export type ListXdslAntiSpamsError = OvhOpError;
+/** List antiSpams for this access */
+export declare const listXdslAntiSpams: API.OperationMethod<ListXdslAntiSpamsRequest, ListXdslAntiSpamsResponse, ListXdslAntiSpamsError, OvhOpContext>;
+export type ListXdslEmailProError = OvhOpError;
+/** List available services */
+export declare const listXdslEmailPro: API.OperationMethod<ListXdslEmailProRequest, ListXdslEmailProResponse, ListXdslEmailProError, OvhOpContext>;
+export type ListXdslFiberEligibilitiesError = OvhOpError;
+/** List fiber eligibilities for this access */
+export declare const listXdslFiberEligibilities: API.OperationMethod<ListXdslFiberEligibilitiesRequest, ListXdslFiberEligibilitiesResponse, ListXdslFiberEligibilitiesError, OvhOpContext>;
+export type ListXdslIncidentsError = OvhOpError;
+/** List of incidents */
+export declare const listXdslIncidents: API.OperationMethod<ListXdslIncidentsRequest, ListXdslIncidentsResponse, ListXdslIncidentsError, OvhOpContext>;
+export type ListXdslIpsError = OvhOpError;
+/** List of IPs addresses for this access */
+export declare const listXdslIps: API.OperationMethod<ListXdslIpsRequest, ListXdslIpsResponse, ListXdslIpsError, OvhOpContext>;
+export type ListXdslLineDslamPortAvailableProfilesError = OvhOpError;
+/** List all availables profiles for this port */
+export declare const listXdslLineDslamPortAvailableProfiles: API.OperationMethod<ListXdslLineDslamPortAvailableProfilesRequest, ListXdslLineDslamPortAvailableProfilesResponse, ListXdslLineDslamPortAvailableProfilesError, OvhOpContext>;
+export type ListXdslLineDslamPortLogsError = OvhOpError;
+/** Get the logs emitted by the DSLAM for this port */
+export declare const listXdslLineDslamPortLogs: API.OperationMethod<ListXdslLineDslamPortLogsRequest, ListXdslLineDslamPortLogsResponse, ListXdslLineDslamPortLogsError, OvhOpContext>;
+export type ListXdslLinesError = OvhOpError;
+/** The lines of the access */
+export declare const listXdslLines: API.OperationMethod<ListXdslLinesRequest, ListXdslLinesResponse, ListXdslLinesError, OvhOpContext>;
+export type ListXdslLineStatisticsError = OvhOpError;
+/** Get various statistics about the line */
+export declare const listXdslLineStatistics: API.OperationMethod<ListXdslLineStatisticsRequest, ComplexTypeUnitAndValuesXdslTimestampAndValue, ListXdslLineStatisticsError, OvhOpContext>;
+export type ListXdslModemAvailableACSBackendError = OvhOpError;
+/** List available ACS backend for this modem */
+export declare const listXdslModemAvailableACSBackend: API.OperationMethod<ListXdslModemAvailableACSBackendRequest, ListXdslModemAvailableACSBackendResponse, ListXdslModemAvailableACSBackendError, OvhOpContext>;
+export type ListXdslModemAvailableWLANChannelError = OvhOpError;
+/** List available WLAN channel for this modem */
+export declare const listXdslModemAvailableWLANChannel: API.OperationMethod<ListXdslModemAvailableWLANChannelRequest, ListXdslModemAvailableWLANChannelResponse, ListXdslModemAvailableWLANChannelError, OvhOpContext>;
+export type ListXdslModemConnectedDevicesError = OvhOpError;
+/** List of devices connected on this modem */
+export declare const listXdslModemConnectedDevices: API.OperationMethod<ListXdslModemConnectedDevicesRequest, ListXdslModemConnectedDevicesResponse, ListXdslModemConnectedDevicesError, OvhOpContext>;
+export type ListXdslModemFirmwareAvailableError = OvhOpError;
+/** List available firmware for this modem */
+export declare const listXdslModemFirmwareAvailable: API.OperationMethod<ListXdslModemFirmwareAvailableRequest, ListXdslModemFirmwareAvailableResponse, ListXdslModemFirmwareAvailableError, OvhOpContext>;
+export type ListXdslModemLanError = OvhOpError;
+/** List of LANs on this modem */
+export declare const listXdslModemLan: API.OperationMethod<ListXdslModemLanRequest, ListXdslModemLanResponse, ListXdslModemLanError, OvhOpContext>;
+export type ListXdslModemLanDhcpError = OvhOpError;
+/** List of DHCP on this modem */
+export declare const listXdslModemLanDhcp: API.OperationMethod<ListXdslModemLanDhcpRequest, ListXdslModemLanDhcpResponse, ListXdslModemLanDhcpError, OvhOpContext>;
+export type ListXdslModemWifiError = OvhOpError;
+/** List of WLANs on this modem */
+export declare const listXdslModemWifi: API.OperationMethod<ListXdslModemWifiRequest, ListXdslModemWifiResponse, ListXdslModemWifiError, OvhOpContext>;
+export type ListXdslModemWifiRadioError = OvhOpError;
+/** List of wifiRadios on this modem */
+export declare const listXdslModemWifiRadio: API.OperationMethod<ListXdslModemWifiRadioRequest, ListXdslModemWifiRadioResponse, ListXdslModemWifiRadioError, OvhOpContext>;
+export type ListXdslOrderFollowupError = OvhOpError;
+/** Get the status of the order */
+export declare const listXdslOrderFollowup: API.OperationMethod<ListXdslOrderFollowupRequest, ListXdslOrderFollowupResponse, ListXdslOrderFollowupError, OvhOpContext>;
+export type ListXdslRadiusConnectionLogsError = OvhOpError;
+/** List the radius connection logs */
+export declare const listXdslRadiusConnectionLogs: API.OperationMethod<ListXdslRadiusConnectionLogsRequest, ListXdslRadiusConnectionLogsResponse, ListXdslRadiusConnectionLogsError, OvhOpContext>;
+export type ListXdslRmaError = OvhOpError;
+/** Return Merchandise Authorisation associated */
+export declare const listXdslRma: API.OperationMethod<ListXdslRmaRequest, ListXdslRmaResponse, ListXdslRmaError, OvhOpContext>;
+export type ListXdslSpareError = OvhOpError;
+/** List available services */
+export declare const listXdslSpare: API.OperationMethod<ListXdslSpareRequest, ListXdslSpareResponse, ListXdslSpareError, OvhOpContext>;
+export type ListXdslSpareBrandsError = OvhOpError;
+/** Get all available spare brands */
+export declare const listXdslSpareBrands: API.OperationMethod<ListXdslSpareBrandsRequest, ListXdslSpareBrandsResponse, ListXdslSpareBrandsError, OvhOpContext>;
+export type ListXdslSpareCompatibleReplacementError = OvhOpError;
+/** Return the list of brand compatible to be replaced */
+export declare const listXdslSpareCompatibleReplacement: API.OperationMethod<ListXdslSpareCompatibleReplacementRequest, ListXdslSpareCompatibleReplacementResponse, ListXdslSpareCompatibleReplacementError, OvhOpContext>;
+export type ListXdslStatisticsError = OvhOpError;
+/** Get various statistics about this access */
+export declare const listXdslStatistics: API.OperationMethod<ListXdslStatisticsRequest, ComplexTypeUnitAndValuesXdslAccessLatency, ListXdslStatisticsError, OvhOpContext>;
+export type ListXdslTasksError = OvhOpError;
+/** Tasks scheduled for this access */
+export declare const listXdslTasks: API.OperationMethod<ListXdslTasksRequest, ListXdslTasksResponse, ListXdslTasksError, OvhOpContext>;
+export type PutXdslError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdsl: API.OperationMethod<PutXdslRequest, PutXdslResponse, PutXdslError, OvhOpContext>;
+export type PutXdslEmailProError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslEmailPro: API.OperationMethod<PutXdslEmailProRequest, PutXdslEmailProResponse, PutXdslEmailProError, OvhOpContext>;
+export type PutXdslModemError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslModem: API.OperationMethod<PutXdslModemRequest, PutXdslModemResponse, PutXdslModemError, OvhOpContext>;
+export type PutXdslModemLanError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslModemLan: API.OperationMethod<PutXdslModemLanRequest, PutXdslModemLanResponse, PutXdslModemLanError, OvhOpContext>;
+export type PutXdslModemLanDhcpError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslModemLanDhcp: API.OperationMethod<PutXdslModemLanDhcpRequest, PutXdslModemLanDhcpResponse, PutXdslModemLanDhcpError, OvhOpContext>;
+export type PutXdslModemWifiError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslModemWifi: API.OperationMethod<PutXdslModemWifiRequest, PutXdslModemWifiResponse, PutXdslModemWifiError, OvhOpContext>;
+export type PutXdslModemWifiRadioError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslModemWifiRadio: API.OperationMethod<PutXdslModemWifiRadioRequest, XdslTask, PutXdslModemWifiRadioError, OvhOpContext>;
+export type PutXdslRmaError = OvhOpError;
+/** Alter this object properties */
+export declare const putXdslRma: API.OperationMethod<PutXdslRmaRequest, PutXdslRmaResponse, PutXdslRmaError, OvhOpContext>;
+export type PutXdslServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putXdslServiceInfos: API.OperationMethod<PutXdslServiceInfosRequest, PutXdslServiceInfosResponse, PutXdslServiceInfosError, OvhOpContext>;
+export type PutXdslSpareServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putXdslSpareServiceInfos: API.OperationMethod<PutXdslSpareServiceInfosRequest, PutXdslSpareServiceInfosResponse, PutXdslSpareServiceInfosError, OvhOpContext>;
+export type RebootModemError = OvhOpError;
+/** Reboot the modem */
+export declare const rebootModem: API.OperationMethod<RebootModemRequest, XdslTask, RebootModemError, OvhOpContext>;
+export type RefreshXdslModemConnectedDevicesError = OvhOpError;
+/** Refresh the list of connected devices on the modem */
+export declare const refreshXdslModemConnectedDevices: API.OperationMethod<RefreshXdslModemConnectedDevicesRequest, XdslTask, RefreshXdslModemConnectedDevicesError, OvhOpContext>;
+export type RemoveDHCPStaticAddressError = OvhOpError;
+/** Delete this port mapping */
+export declare const removeDHCPStaticAddress: API.OperationMethod<RemoveDHCPStaticAddressRequest, XdslTask, RemoveDHCPStaticAddressError, OvhOpContext>;
+export type RemoveMonitoringNotificationError = OvhOpError;
+/** Delete this notification */
+export declare const removeMonitoringNotification: API.OperationMethod<RemoveMonitoringNotificationRequest, RemoveMonitoringNotificationResponse, RemoveMonitoringNotificationError, OvhOpContext>;
+export type RemovePortMappingError = OvhOpError;
+/** Delete this port mapping */
+export declare const removePortMapping: API.OperationMethod<RemovePortMappingRequest, XdslTask, RemovePortMappingError, OvhOpContext>;
+export type ReplaceAccessModemError = OvhOpError;
+/** Replace access modem by last model, fees will be applied. */
+export declare const replaceAccessModem: API.OperationMethod<ReplaceAccessModemRequest, OrderOrder, ReplaceAccessModemError, OvhOpContext>;
+export type ReplaceModemBySpareError = OvhOpError;
+/** Replace the modem by its spare */
+export declare const replaceModemBySpare: API.OperationMethod<ReplaceModemBySpareRequest, ReplaceModemBySpareResponse, ReplaceModemBySpareError, OvhOpContext>;
+export type RequestTotalDeconsolidationError = OvhOpError;
+/** Switch this access to total deconsolidation */
+export declare const requestTotalDeconsolidation: API.OperationMethod<RequestTotalDeconsolidationRequest, XdslTask, RequestTotalDeconsolidationError, OvhOpContext>;
+export type ResetModemConfigurationError = OvhOpError;
+/** Reset the modem to its default configuration */
+export declare const resetModemConfiguration: API.OperationMethod<ResetModemConfigurationRequest, XdslTask, ResetModemConfigurationError, OvhOpContext>;
+export type ResetXdslLinesDslamPortError = OvhOpError;
+/** Reset the port on the DSLAM */
+export declare const resetXdslLinesDslamPort: API.OperationMethod<ResetXdslLinesDslamPortRequest, XdslTask, ResetXdslLinesDslamPortError, OvhOpContext>;
+export type ResetXdslModemPortMappingConfigError = OvhOpError;
+/** Remove all the current port mapping rules */
+export declare const resetXdslModemPortMappingConfig: API.OperationMethod<ResetXdslModemPortMappingConfigRequest, ResetXdslModemPortMappingConfigResponse, ResetXdslModemPortMappingConfigError, OvhOpContext>;
+export type ResiliateAccessError = OvhOpError;
+/** Resiliate the access */
+export declare const resiliateAccess: API.OperationMethod<ResiliateAccessRequest, XdslResiliationFollowUpDetail, ResiliateAccessError, OvhOpContext>;
+export type SearchXdslOrderMeetingsError = OvhOpError;
+/** Search for available line creation meeting time slots, for order only */
+export declare const searchXdslOrderMeetings: API.OperationMethod<SearchXdslOrderMeetingsRequest, XdslAsyncTaskConnectivityEligibilityMeetings, SearchXdslOrderMeetingsError, OvhOpContext>;
+export type SendXdslOrderToProviderError = OvhOpError;
+/** Unlock order in "waitingCustomer" status */
+export declare const sendXdslOrderToProvider: API.OperationMethod<SendXdslOrderToProviderRequest, SendXdslOrderToProviderResponse, SendXdslOrderToProviderError, OvhOpContext>;
+export type SetWifiMeshStatusError = OvhOpError;
+/** Change the status of mesh on this modem */
+export declare const setWifiMeshStatus: API.OperationMethod<SetWifiMeshStatusRequest, XdslTask, SetWifiMeshStatusError, OvhOpContext>;
+export type SetWifiOneSsidStatusError = OvhOpError;
+/** Change the status of onessid on this modem */
+export declare const setWifiOneSsidStatus: API.OperationMethod<SetWifiOneSsidStatusRequest, XdslTask, SetWifiOneSsidStatusError, OvhOpContext>;
+export type UpdateBlocIPStatusError = OvhOpError;
+/** Change the status of the Bloc IP on modem */
+export declare const updateBlocIPStatus: API.OperationMethod<UpdateBlocIPStatusRequest, XdslTask, UpdateBlocIPStatusError, OvhOpContext>;
+export type UpdateContentSharingStatusError = OvhOpError;
+/** Change the status of contentSharing on modem */
+export declare const updateContentSharingStatus: API.OperationMethod<UpdateContentSharingStatusRequest, XdslTask, UpdateContentSharingStatusError, OvhOpContext>;
+export type UpdateDHCPStaticAddressError = OvhOpError;
+/** Alter this object properties */
+export declare const updateDHCPStaticAddress: API.OperationMethod<UpdateDHCPStaticAddressRequest, UpdateDHCPStaticAddressResponse, UpdateDHCPStaticAddressError, OvhOpContext>;
+export type UpdateFTPStatusError = OvhOpError;
+/** Change the status of the ftp service on modem */
+export declare const updateFTPStatus: API.OperationMethod<UpdateFTPStatusRequest, XdslTask, UpdateFTPStatusError, OvhOpContext>;
+export type UpdateIpError = OvhOpError;
+/** Change the status of the IPv6 for this access */
+export declare const updateIp: API.OperationMethod<UpdateIpRequest, XdslTask, UpdateIpError, OvhOpContext>;
+export type UpdateIpsecAlgStatusError = OvhOpError;
+/** Change the status of the ipsec alg service on modem */
+export declare const updateIpsecAlgStatus: API.OperationMethod<UpdateIpsecAlgStatusRequest, XdslTask, UpdateIpsecAlgStatusError, OvhOpContext>;
+export type UpdateLineDiagnosticError = OvhOpError;
+/** Update and get advanced diagnostic of the line */
+export declare const updateLineDiagnostic: API.OperationMethod<UpdateLineDiagnosticRequest, XdslLineDiagnosticDiagnostic, UpdateLineDiagnosticError, OvhOpContext>;
+export type UpdateMailSendingError = OvhOpError;
+/** Enable or disable email sending ability */
+export declare const updateMailSending: API.OperationMethod<UpdateMailSendingRequest, XdslTask, UpdateMailSendingError, OvhOpContext>;
+export type UpdateModemCallWaitingError = OvhOpError;
+/** Change the status of callWaiting on modem */
+export declare const updateModemCallWaiting: API.OperationMethod<UpdateModemCallWaitingRequest, XdslTask, UpdateModemCallWaitingError, OvhOpContext>;
+export type UpdateModemTemplateError = OvhOpError;
+/** Alter this object properties */
+export declare const updateModemTemplate: API.OperationMethod<UpdateModemTemplateRequest, UpdateModemTemplateResponse, UpdateModemTemplateError, OvhOpContext>;
+export type UpdateMonitoringNotificationError = OvhOpError;
+/** Alter this object properties */
+export declare const updateMonitoringNotification: API.OperationMethod<UpdateMonitoringNotificationRequest, UpdateMonitoringNotificationResponse, UpdateMonitoringNotificationError, OvhOpContext>;
+export type UpdatePortMappingError = OvhOpError;
+/** Alter this object properties */
+export declare const updatePortMapping: API.OperationMethod<UpdatePortMappingRequest, UpdatePortMappingResponse, UpdatePortMappingError, OvhOpContext>;
+export type UpdateRIOError = OvhOpError;
+/** Update RIO, or disable portability, for order in error because of missing or invalid RIO */
+export declare const updateRIO: API.OperationMethod<UpdateRIORequest, UpdateRIOResponse, UpdateRIOError, OvhOpContext>;
+export type UpdateRMATypeError = OvhOpError;
+/** Change RMA type */
+export declare const updateRMAType: API.OperationMethod<UpdateRMATypeRequest, UpdateRMATypeResponse, UpdateRMATypeError, OvhOpContext>;
+export type UpdateSipAlgStatusError = OvhOpError;
+/** Change the status of the sip alg service on modem */
+export declare const updateSipAlgStatus: API.OperationMethod<UpdateSipAlgStatusRequest, XdslTask, UpdateSipAlgStatusError, OvhOpContext>;
+export type UpdateUpnpStatusError = OvhOpError;
+/** Change the status of the Upnp on modem */
+export declare const updateUpnpStatus: API.OperationMethod<UpdateUpnpStatusRequest, XdslTask, UpdateUpnpStatusError, OvhOpContext>;
+//# sourceMappingURL=xdsl.d.ts.map