node-ovh-ts/dist/handlers/Vrack.d.ts

OVH API wrapper library for TypeScript

import { VrackVrackZoneEnum } from '../models/VrackVrackZoneEnum.js';
import { VrackIplb } from '../models/VrackIplb.js';
import { VrackDedicatedServerInterface } from '../models/VrackDedicatedServerInterface.js';
import { ServicesNonExpiringService } from '../models/ServicesNonExpiringService.js';
import { VrackTask } from '../models/VrackTask.js';
import { VrackPccDatacenter } from '../models/VrackPccDatacenter.js';
import { VrackEligibleServicesResponse } from '../models/VrackEligibleServicesResponse.js';
import { VrackAllowedDedicatedServerInterfaces } from '../models/VrackAllowedDedicatedServerInterfaces.js';
import { VrackIp } from '../models/VrackIp.js';
import { VrackDedicatedServer } from '../models/VrackDedicatedServer.js';
import { VrackLegacyVrack } from '../models/VrackLegacyVrack.js';
import { VrackVrack } from '../models/VrackVrack.js';
import { VrackDedicatedConnect } from '../models/VrackDedicatedConnect.js';
import { VrackOvhCloudConnect } from '../models/VrackOvhCloudConnect.js';
import { VrackCloudProject } from '../models/VrackCloudProject.js';
import { DedicatedServerMrtgTimestampValue } from '../models/DedicatedServerMrtgTimestampValue.js';
import { VrackDedicatedCloud } from '../models/VrackDedicatedCloud.js';
import { VrackAllowedServices } from '../models/VrackAllowedServices.js';
import OVHBase from '../ovh.js';
import '../models/ServiceStateEnum.js';
import '../models/VrackTaskStatusEnum.js';
import '../models/VrackEligibleServices.js';
import '../models/VrackEligibleDedicatedServerInterfaces.js';
import '../endpoints.js';

declare class VrackHandler {
    ovh: OVHBase;
    constructor(ovh: OVHBase);
    /** List available services */
    list: () => Promise<string[]>;
    /** Get this object properties */
    getByServiceName: (serviceName: string) => Promise<VrackVrack>;
    /** Alter this object properties */
    updateByServiceName: (serviceName: string, body: VrackVrack) => Promise<void>;
    /** List all services allowed in this vrack */
    listAllowedServicesByServiceName: (serviceName: string) => Promise<VrackAllowedServices>;
    /** vrack for publicCloud project */
    getCloudProjectByServiceName: (serviceName: string) => Promise<string[]>;
    /** add a publicCloud project to this vrack */
    addCloudProjectByServiceName: (serviceName: string, body: {
        project: string;
    }) => Promise<VrackTask>;
    /** remove this publicCloud project from this vrack */
    deleteCloudProjectByServiceNameAndProject: (project: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getCloudProjectByServiceNameAndProject: (project: string, serviceName: string) => Promise<VrackCloudProject>;
    /** vrack dedicated cloud (VmNetwork) */
    getDedicatedCloudByServiceName: (serviceName: string) => Promise<string[]>;
    /** add a dedicatedCloud (VmNetwork) to this vrack */
    addDedicatedCloudByServiceName: (serviceName: string, body: {
        dedicatedCloud: string;
    }) => Promise<VrackTask>;
    /** remove this dedicatedCloud (VmNetwork) from this vrack */
    deleteDedicatedCloudByServiceNameAndDedicatedCloud: (dedicatedCloud: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getDedicatedCloudByServiceNameAndDedicatedCloud: (dedicatedCloud: string, serviceName: string) => Promise<VrackDedicatedCloud>;
    /** vrack dedicated cloud datacenter */
    getDedicatedCloudDatacenterByServiceName: (serviceName: string) => Promise<string[]>;
    /** Get this object properties */
    getDedicatedCloudDatacenterByServiceNameAndDatacenter: (datacenter: string, serviceName: string) => Promise<VrackPccDatacenter>;
    /** Vracks allowed for your dedicatedCloud datacenter */
    getDedicatedCloudDatacenterAllowedVrackByServiceNameAndDatacenter: (datacenter: string, serviceName: string) => Promise<string[]>;
    /** Move your dedicatedCloud datacenter from a Vrack to another */
    postDedicatedCloudDatacenterMoveByServiceNameAndDatacenter: (datacenter: string, serviceName: string, body: {
        targetServiceName: string;
    }) => Promise<VrackTask>;
    /** vrack dedicated connect */
    getDedicatedConnectByServiceName: (serviceName: string) => Promise<string[]>;
    /** Get this object properties */
    getDedicatedConnectByServiceNameAndName: (name: string, serviceName: string) => Promise<VrackDedicatedConnect>;
    /** Alter this object properties */
    updateDedicatedConnectByServiceNameAndName: (name: string, serviceName: string, body: VrackDedicatedConnect) => Promise<void>;
    /** vrack for dedicated server */
    getDedicatedServerByServiceName: (serviceName: string) => Promise<string[]>;
    /** add a dedicated server to this vrack (LEGACY) */
    addDedicatedServerByServiceName: (serviceName: string, body: {
        dedicatedServer: string;
    }) => Promise<VrackTask>;
    /** remove this server from this vrack (LEGACY) */
    deleteDedicatedServerByServiceNameAndDedicatedServer: (dedicatedServer: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getDedicatedServerByServiceNameAndDedicatedServer: (dedicatedServer: string, serviceName: string) => Promise<VrackDedicatedServer>;
    /** Retrieve vrack traffic graph values (LEGACY) */
    getDedicatedServerMrtgByServiceNameAndDedicatedServer: (dedicatedServer: string, serviceName: string) => Promise<DedicatedServerMrtgTimestampValue[]>;
    /** vrack for dedicated server interface */
    getDedicatedServerInterfaceByServiceName: (serviceName: string) => Promise<string[]>;
    /** add a dedicated server interface to this vrack */
    addDedicatedServerInterfaceByServiceName: (serviceName: string, body: {
        dedicatedServerInterface: string;
    }) => Promise<VrackTask>;
    /** remove this server interface from this vrack */
    deleteDedicatedServerInterfaceByServiceNameAndDedicatedServerInterface: (dedicatedServerInterface: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getDedicatedServerInterfaceByServiceNameAndDedicatedServerInterface: (dedicatedServerInterface: string, serviceName: string) => Promise<VrackDedicatedServerInterface>;
    /** Details for all dedicated server interfaces in this vrack */
    getDedicatedServerInterfaceDetailsByServiceName: (serviceName: string) => Promise<VrackAllowedDedicatedServerInterfaces[]>;
    /** List all eligible services for this vRack asynchronously */
    listEligibleServicesByServiceName: (serviceName: string) => Promise<VrackEligibleServicesResponse>;
    /** vrack for IP blocks */
    getIpByServiceName: (serviceName: string) => Promise<string[]>;
    /** add an IP block to this vrack */
    addIpByServiceName: (serviceName: string, body: {
        block: string;
    }) => Promise<VrackTask>;
    /** remove this IP block from this vrack */
    deleteIpByServiceNameAndIp: (ip: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getIpByServiceNameAndIp: (ip: string, serviceName: string) => Promise<VrackIp>;
    /** Announce IP to zone for vrack */
    postIpAnnounceInZoneByServiceNameAndIp: (ip: string, serviceName: string, body: {
        zone: VrackVrackZoneEnum;
    }) => Promise<VrackTask>;
    /** Zone available to announce your block */
    getIpAvailableZoneByServiceNameAndIp: (ip: string, serviceName: string) => Promise<VrackVrackZoneEnum[]>;
    /** vrack for ipLoadbalancing */
    getIpLoadbalancingByServiceName: (serviceName: string) => Promise<string[]>;
    /** add an ipLoadbalancing to this vrack */
    addIpLoadbalancingByServiceName: (serviceName: string, body: {
        ipLoadbalancing: string;
    }) => Promise<VrackTask>;
    /** remove this ipLoadbalancing from this vrack */
    deleteIpLoadbalancingByServiceNameAndIpLoadbalancing: (ipLoadbalancing: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getIpLoadbalancingByServiceNameAndIpLoadbalancing: (ipLoadbalancing: string, serviceName: string) => Promise<VrackIplb>;
    /** vrack for legacy vrack */
    getLegacyVrackByServiceName: (serviceName: string) => Promise<string[]>;
    /** add a legacy vrack (vrackXXXX) to this vrack (pn-XXXX) */
    addLegacyVrackByServiceName: (serviceName: string, body: {
        legacyVrack: string;
    }) => Promise<VrackTask>;
    /** remove this legacy vrack (vrackXXXX) from this vrack (pn-XXXX) */
    deleteLegacyVrackByServiceNameAndLegacyVrack: (legacyVrack: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getLegacyVrackByServiceNameAndLegacyVrack: (legacyVrack: string, serviceName: string) => Promise<VrackLegacyVrack>;
    /** vrack for ovhCloudConnect */
    getOvhCloudConnectByServiceName: (serviceName: string) => Promise<string[]>;
    /** Add an ovhCloudConnect to the vrack */
    addOvhCloudConnectByServiceName: (serviceName: string, body: {
        ovhCloudConnect: string;
    }) => Promise<VrackTask>;
    /** Remove the ovhCloudConnect from the vrack */
    deleteOvhCloudConnectByServiceNameAndOvhCloudConnect: (ovhCloudConnect: string, serviceName: string) => Promise<VrackTask>;
    /** Get this object properties */
    getOvhCloudConnectByServiceNameAndOvhCloudConnect: (ovhCloudConnect: string, serviceName: string) => Promise<VrackOvhCloudConnect>;
    /** Get this object properties */
    getServiceInfosByServiceName: (serviceName: string) => Promise<ServicesNonExpiringService>;
    /** vrack tasks */
    getTaskByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getTaskByServiceNameAndTaskId: (serviceName: string, taskId: number) => Promise<VrackTask>;
}

export { VrackHandler };