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

OVH API wrapper library for TypeScript

import { HostingPrivateDatabaseAvailableOrderCapacities } from '../models/HostingPrivateDatabaseAvailableOrderCapacities.js';
import { ServicesService } from '../models/ServicesService.js';
import { ServiceTerminationFutureUseEnum } from '../models/ServiceTerminationFutureUseEnum.js';
import { HostingPrivateDatabaseAvailableVersionEnum } from '../models/HostingPrivateDatabaseAvailableVersionEnum.js';
import { HostingPrivateDatabaseConfiguration } from '../models/HostingPrivateDatabaseConfiguration.js';
import { HostingPrivateDatabaseDatabaseDump } from '../models/HostingPrivateDatabaseDatabaseDump.js';
import { HostingPrivateDatabaseDatabaseExtension } from '../models/HostingPrivateDatabaseDatabaseExtension.js';
import { HostingPrivateDatabaseUser } from '../models/HostingPrivateDatabaseUser.js';
import { HostingPrivateDatabaseTask } from '../models/HostingPrivateDatabaseTask.js';
import { HostingPrivateDatabaseWhitelist } from '../models/HostingPrivateDatabaseWhitelist.js';
import { HostingPrivateDatabaseService } from '../models/HostingPrivateDatabaseService.js';
import { HostingPrivateDatabaseGrantGrantEnum } from '../models/HostingPrivateDatabaseGrantGrantEnum.js';
import { HostingPrivateDatabaseGrant } from '../models/HostingPrivateDatabaseGrant.js';
import { HostingPrivateDatabaseOom } from '../models/HostingPrivateDatabaseOom.js';
import { HostingPrivateDatabaseCpuThrottle } from '../models/HostingPrivateDatabaseCpuThrottle.js';
import { HostingPrivateDatabaseDump } from '../models/HostingPrivateDatabaseDump.js';
import { ServiceTerminationReasonEnum } from '../models/ServiceTerminationReasonEnum.js';
import { HostingPrivateDatabaseTemporaryLogsLink } from '../models/HostingPrivateDatabaseTemporaryLogsLink.js';
import { HostingPrivateDatabaseDatabase } from '../models/HostingPrivateDatabaseDatabase.js';
import { HostingPrivateDatabaseWebhostingNetwork } from '../models/HostingPrivateDatabaseWebhostingNetwork.js';
import OVHBase from '../ovh.js';
import '../models/HostingPrivateDatabaseAvailableRamSizeEnum.js';
import '../models/HostingPrivateDatabaseDatacenterEnum.js';
import '../models/HostingPrivateDatabaseOfferEnum.js';
import '../models/ServiceStateEnum.js';
import '../models/ServiceRenewType.js';
import '../models/ServiceRenewalTypeEnum.js';
import '../models/HostingPrivateDatabaseConfigurationStatus.js';
import '../models/HostingPrivateDatabaseConfigurationDetail.js';
import '../models/HostingPrivateDatabaseConfigurationDetailType.js';
import '../models/HostingPrivateDatabaseDatabaseExtensionStatus.js';
import '../models/HostingPrivateDatabaseUserDatabase.js';
import '../models/HostingPrivateDatabaseTaskFunctionEnum.js';
import '../models/HostingPrivateDatabaseTaskStatusEnum.js';
import '../models/HostingPrivateDatabaseWhitelistStatus.js';
import '../models/HostingPrivateDatabaseGraphEndpoint.js';
import '../models/HostingPrivateDatabaseTypeEnum.js';
import '../models/HostingPrivateDatabaseCapability.js';
import '../models/HostingPrivateDatabaseStateEnum.js';
import '../models/HostingPrivateDatabaseDatabaseUser.js';
import '../models/HostingPrivateDatabaseWebhostingNetworkStatus.js';
import '../endpoints.js';

declare class HostingPrivateDatabaseHandler {
    ovh: OVHBase;
    constructor(ovh: OVHBase);
    /** List available services */
    listPrivateDatabase: () => Promise<string[]>;
    /** Get available order capacitie */
    getPrivateDatabaseAvailableOrderCapacities: () => Promise<HostingPrivateDatabaseAvailableOrderCapacities>;
    /** Get this object properties */
    getPrivateDatabaseByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseService>;
    /** Alter this object properties */
    updatePrivateDatabaseByServiceName: (serviceName: string, body: HostingPrivateDatabaseService) => Promise<void>;
    /** Get the availables versions for this private database */
    getPrivateDatabaseAvailableVersionsByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseAvailableVersionEnum[]>;
    /** Launch a contact change procedure */
    launchPrivateDatabaseChangeContactByServiceName: (serviceName: string, body: {
        contactAdmin?: string;
        contactBilling?: string;
        contactTech?: string;
    }) => Promise<number[]>;
    /** Change your ftp admin password */
    updatePrivateDatabaseFtpPasswordByServiceName: (serviceName: string, body: {
        password: string;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Change the private database engine version */
    updatePrivateDatabaseVersionByServiceName: (serviceName: string, body: {
        version: HostingPrivateDatabaseAvailableVersionEnum;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseConfigByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseConfiguration>;
    /** Update the configuration */
    updatePrivateDatabaseConfigByServiceName: (serviceName: string, body: {
        parameters: string;
    }) => Promise<HostingPrivateDatabaseConfiguration>;
    /** Confirm termination of your service */
    confirmPrivateDatabaseTerminationByServiceName: (serviceName: string, body: {
        commentary?: string;
        futureUse?: ServiceTerminationFutureUseEnum;
        reason?: ServiceTerminationReasonEnum;
        token: string;
    }) => Promise<string>;
    /** List of privatesql CPU throttle */
    listPrivateDatabaseCpuThrottleByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseCpuThrottle[]>;
    /** Databases linked to your private database service */
    getPrivateDatabaseDatabaseByServiceName: (serviceName: string) => Promise<string[]>;
    /** Create a new database on your private database service */
    createPrivateDatabaseDatabaseByServiceName: (serviceName: string, body: {
        databaseName: string;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Delete the database */
    deletePrivateDatabaseDatabaseByServiceNameAndDatabaseName: (databaseName: string, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseDatabaseByServiceNameAndDatabaseName: (databaseName: string, serviceName: string) => Promise<HostingPrivateDatabaseDatabase>;
    /** Dump available for your databases */
    getPrivateDatabaseDatabaseDumpByServiceNameAndDatabaseName: (databaseName: string, serviceName: string) => Promise<number[]>;
    /** Request the dump of this database ( an email will be send with a link available 30 days ) */
    postPrivateDatabaseDatabaseDumpByServiceNameAndDatabaseName: (databaseName: string, serviceName: string, body: {
        sendEmail?: boolean;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Delete dump before expiration date */
    deletePrivateDatabaseDatabaseDumpByServiceNameAndDatabaseNameAndId: (databaseName: string, id: number, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseDatabaseDumpByServiceNameAndDatabaseNameAndId: (databaseName: string, id: number, serviceName: string) => Promise<HostingPrivateDatabaseDatabaseDump>;
    /** Request the restore from this dump */
    postPrivateDatabaseDatabaseDumpRestoreByServiceNameAndDatabaseNameAndId: (databaseName: string, id: number, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Extensions linked to your database */
    getPrivateDatabaseDatabaseExtensionByServiceNameAndDatabaseName: (databaseName: string, serviceName: string) => Promise<string[]>;
    /** Get this object properties */
    getPrivateDatabaseDatabaseExtensionByServiceNameAndDatabaseNameAndExtensionName: (databaseName: string, extensionName: string, serviceName: string) => Promise<HostingPrivateDatabaseDatabaseExtension>;
    /** Disable an extension from a database */
    disablePrivateDatabaseDatabaseExtensionByServiceNameAndDatabaseNameAndExtensionName: (databaseName: string, extensionName: string, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Enable an extension on a database */
    enablePrivateDatabaseDatabaseExtensionByServiceNameAndDatabaseNameAndExtensionName: (databaseName: string, extensionName: string, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Request the import in this database */
    postPrivateDatabaseDatabaseImportByServiceNameAndDatabaseName: (databaseName: string, serviceName: string, body: {
        documentId: string;
        flushDatabase?: boolean;
        sendEmail?: boolean;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Create a new database/user and grant it */
    createPrivateDatabaseDatabaseWizardByServiceName: (serviceName: string, body: {
        databaseName: string;
        grant: HostingPrivateDatabaseGrantGrantEnum;
        password: string;
        userName: string;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Dumps available for your private database service */
    getPrivateDatabaseDumpByServiceName: (serviceName: string) => Promise<number[]>;
    /** Delete dump before expiration date */
    deletePrivateDatabaseDumpByServiceNameAndDumpId: (dumpId: number, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseDumpByServiceNameAndDumpId: (dumpId: number, serviceName: string) => Promise<HostingPrivateDatabaseDump>;
    /** Request the restore from this dump */
    postPrivateDatabaseDumpRestoreByServiceNameAndDumpId: (dumpId: number, serviceName: string, body: {
        databaseName: string;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Generate a temporary url to retrieve instance logs */
    postPrivateDatabaseGenerateTemporaryLogsLinkByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTemporaryLogsLink>;
    /** List of privatesql OOM kill */
    listPrivateDatabaseOomByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseOom[]>;
    /** Refresh the quota of your private database */
    postPrivateDatabaseQuotaRefreshByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Restart the private database */
    postPrivateDatabaseRestartByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseServiceInfosByServiceName: (serviceName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updatePrivateDatabaseServiceInfosByServiceName: (serviceName: string, body: ServicesService) => Promise<void>;
    /** Start the private database */
    postPrivateDatabaseStartByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Stop the private database */
    postPrivateDatabaseStopByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Tasks attached to your private database service */
    getPrivateDatabaseTasksByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getPrivateDatabaseTasksByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Terminate your service */
    postPrivateDatabaseTerminateByServiceName: (serviceName: string) => Promise<string>;
    /** User allowed to connect on your databases */
    getPrivateDatabaseUserByServiceName: (serviceName: string) => Promise<string[]>;
    /** Create a new user on your service */
    createPrivateDatabaseUserByServiceName: (serviceName: string, body: {
        password: string;
        userName: string;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Delete a user */
    deletePrivateDatabaseUserByServiceNameAndUserName: (serviceName: string, userName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseUserByServiceNameAndUserName: (serviceName: string, userName: string) => Promise<HostingPrivateDatabaseUser>;
    /** Request a change password for a user */
    postPrivateDatabaseUserChangePasswordByServiceNameAndUserName: (serviceName: string, userName: string, body: {
        password: string;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** User grant's on your databases */
    getPrivateDatabaseUserGrantByServiceNameAndUserName: (serviceName: string, userName: string) => Promise<string[]>;
    /** Add grant on a database */
    addPrivateDatabaseUserGrantByServiceNameAndUserName: (serviceName: string, userName: string, body: {
        databaseName: string;
        grant: HostingPrivateDatabaseGrantGrantEnum;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Delete a grant on a database */
    deletePrivateDatabaseUserGrantByServiceNameAndUserNameAndDatabaseName: (databaseName: string, serviceName: string, userName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseUserGrantByServiceNameAndUserNameAndDatabaseName: (databaseName: string, serviceName: string, userName: string) => Promise<HostingPrivateDatabaseGrant>;
    /** Update user grant */
    updatePrivateDatabaseUserGrantByServiceNameAndUserNameAndDatabaseName: (databaseName: string, serviceName: string, userName: string, body: {
        grant: HostingPrivateDatabaseGrantGrantEnum;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Disable Webhosting network */
    disablePrivateDatabaseWebhostingNetworkByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseWebhostingNetworkByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseWebhostingNetwork>;
    /** Enable Webhosting network */
    enablePrivateDatabaseWebhostingNetworkByServiceName: (serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** List linked webs */
    listPrivateDatabaseWebsByServiceName: (serviceName: string) => Promise<string[]>;
    /** Whitelist allowed on your privatesql */
    getPrivateDatabaseWhitelistByServiceName: (serviceName: string) => Promise<string[]>;
    /** Create a new IP whitelist */
    createPrivateDatabaseWhitelistByServiceName: (serviceName: string, body: {
        ip: string;
        name?: string;
        service?: boolean;
        sftp?: boolean;
    }) => Promise<HostingPrivateDatabaseTask>;
    /** Delete ain IP whitelist */
    deletePrivateDatabaseWhitelistByServiceNameAndIp: (ip: string, serviceName: string) => Promise<HostingPrivateDatabaseTask>;
    /** Get this object properties */
    getPrivateDatabaseWhitelistByServiceNameAndIp: (ip: string, serviceName: string) => Promise<HostingPrivateDatabaseWhitelist>;
    /** Alter this object properties */
    updatePrivateDatabaseWhitelistByServiceNameAndIp: (ip: string, serviceName: string, body: HostingPrivateDatabaseWhitelist) => Promise<void>;
}

export { HostingPrivateDatabaseHandler };