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

OVH API wrapper library for TypeScript

import { HostingWebDatabaseExtraSqlQuotaEnum } from '../models/HostingWebDatabaseExtraSqlQuotaEnum.js';
import { HostingWebLocalSeoDirectoriesList } from '../models/HostingWebLocalSeoDirectoriesList.js';
import { HostingWebOwnLogs } from '../models/HostingWebOwnLogs.js';
import { HostingWebTask } from '../models/HostingWebTask.js';
import { HostingWebLocalSeoLocation } from '../models/HostingWebLocalSeoLocation.js';
import { HostingWebDatabaseDumpDateEnum } from '../models/HostingWebDatabaseDumpDateEnum.js';
import { HostingWebEmailoption } from '../models/HostingWebEmailoption.js';
import { HostingWebDatabaseCreationDatabaseCapabilities } from '../models/HostingWebDatabaseCreationDatabaseCapabilities.js';
import { HostingWebBoostHistory } from '../models/HostingWebBoostHistory.js';
import { HostingWebMailBounce } from '../models/HostingWebMailBounce.js';
import { HostingWebConfiguration } from '../models/HostingWebConfiguration.js';
import { HostingWebBackupTypeEnum } from '../models/HostingWebBackupTypeEnum.js';
import { HostingWebOvhConfigHttpFirewallEnum } from '../models/HostingWebOvhConfigHttpFirewallEnum.js';
import { HostingWebSSL } from '../models/HostingWebSSL.js';
import { ServiceTerminationFutureUseEnum } from '../models/ServiceTerminationFutureUseEnum.js';
import { HostingWebDatabaseDatabaseTypeEnum } from '../models/HostingWebDatabaseDatabaseTypeEnum.js';
import { HostingWebSslReport } from '../models/HostingWebSslReport.js';
import { HostingWebCapabilities } from '../models/HostingWebCapabilities.js';
import { HostingWebService } from '../models/HostingWebService.js';
import { HostingWebUser } from '../models/HostingWebUser.js';
import { HostingWebRuntime } from '../models/HostingWebRuntime.js';
import { HostingWebRequestActionEnum } from '../models/HostingWebRequestActionEnum.js';
import { HostingWebOvhConfigCapabilities } from '../models/HostingWebOvhConfigCapabilities.js';
import { HostingWebOvhConfigAvailableEngineVersionEnum } from '../models/HostingWebOvhConfigAvailableEngineVersionEnum.js';
import { HostingWebDatabaseDatabaseCapabilities } from '../models/HostingWebDatabaseDatabaseCapabilities.js';
import { HostingWebRuntimeTypeEnum } from '../models/HostingWebRuntimeTypeEnum.js';
import { HostingWebCdn } from '../models/HostingWebCdn.js';
import { HostingWebUserLogs } from '../models/HostingWebUserLogs.js';
import { HostingWebAttachedDomainCdnEnum } from '../models/HostingWebAttachedDomainCdnEnum.js';
import { HostingWebDatabaseRequestActionEnum } from '../models/HostingWebDatabaseRequestActionEnum.js';
import { CdnDomainStatistics } from '../models/CdnDomainStatistics.js';
import { ServiceTerminationReasonEnum } from '../models/ServiceTerminationReasonEnum.js';
import { CdnDomainOption } from '../models/CdnDomainOption.js';
import { HostingWebAttachedDomain } from '../models/HostingWebAttachedDomain.js';
import { HostingWebDatabaseVersionEnum } from '../models/HostingWebDatabaseVersionEnum.js';
import { HostingWebModule } from '../models/HostingWebModule.js';
import { HostingWebModuleDependencyType } from '../models/HostingWebModuleDependencyType.js';
import { HostingPrivateDatabaseAvailableRamSizeEnum } from '../models/HostingPrivateDatabaseAvailableRamSizeEnum.js';
import { ServicesService } from '../models/ServicesService.js';
import { HostingWebEmail } from '../models/HostingWebEmail.js';
import { CdnAvailableOptions } from '../models/CdnAvailableOptions.js';
import { HostingWebPublicTask } from '../models/HostingWebPublicTask.js';
import { HostingWebLocalSeoVisibilityCheckResultResponse } from '../models/HostingWebLocalSeoVisibilityCheckResultResponse.js';
import { HostingWebCron } from '../models/HostingWebCron.js';
import { HostingWebEnvVarTypeEnum } from '../models/HostingWebEnvVarTypeEnum.js';
import { HostingWebMailVolumeHistory } from '../models/HostingWebMailVolumeHistory.js';
import { HostingWebDump } from '../models/HostingWebDump.js';
import { HostingWebModuleList } from '../models/HostingWebModuleList.js';
import { HostingWebLocalSeoLocationCountryEnum } from '../models/HostingWebLocalSeoLocationCountryEnum.js';
import { HostingWebOvhConfig } from '../models/HostingWebOvhConfig.js';
import { HostingWebEnvVar } from '../models/HostingWebEnvVar.js';
import { HostingWebModuleLanguageEnum } from '../models/HostingWebModuleLanguageEnum.js';
import { CdnLogs } from '../models/CdnLogs.js';
import { HostingWebLocalSeoVisibilityCheckResponse } from '../models/HostingWebLocalSeoVisibilityCheckResponse.js';
import { HostingWebMailActionEnum } from '../models/HostingWebMailActionEnum.js';
import { HostingWebConfigurationVersionEnum } from '../models/HostingWebConfigurationVersionEnum.js';
import { HostingWebUserSshStateEnum } from '../models/HostingWebUserSshStateEnum.js';
import { HostingWebDatabaseDatabaseCapabilitiesTypeEnum } from '../models/HostingWebDatabaseDatabaseCapabilitiesTypeEnum.js';
import { HostingWebOvhConfigEnvironmentEnum } from '../models/HostingWebOvhConfigEnvironmentEnum.js';
import { CdnDomainAddOption } from '../models/CdnDomainAddOption.js';
import { HostingWebDatabase } from '../models/HostingWebDatabase.js';
import { CdnDomain } from '../models/CdnDomain.js';
import { HostingWebLocalSeoEmailAvailability } from '../models/HostingWebLocalSeoEmailAvailability.js';
import { HostingWebLocalSeoAccount } from '../models/HostingWebLocalSeoAccount.js';
import { HostingWebIndy } from '../models/HostingWebIndy.js';
import { HostingWebOvhConfigRecommendedValues } from '../models/HostingWebOvhConfigRecommendedValues.js';
import { HostingWebAttachedDomainFirewallEnum } from '../models/HostingWebAttachedDomainFirewallEnum.js';
import { CdnOperation } from '../models/CdnOperation.js';
import { HostingWebDatabaseDatabaseCreationTypeEnum } from '../models/HostingWebDatabaseDatabaseCreationTypeEnum.js';
import { HostingWebOvhConfigEngineNameEnum } from '../models/HostingWebOvhConfigEngineNameEnum.js';
import { HostingPrivateDatabaseOrderableVersionEnum } from '../models/HostingPrivateDatabaseOrderableVersionEnum.js';
import { ServiceRenewType } from '../models/ServiceRenewType.js';
import { HostingWebExtrasqlperso } from '../models/HostingWebExtrasqlperso.js';
import { ComplexTypeChartTimestampValue } from '../models/ComplexTypeChartTimestampValue.js';
import { HostingWebDatabaseAvailableVersionStruct } from '../models/HostingWebDatabaseAvailableVersionStruct.js';
import { HostingWebLanguagesEnum } from '../models/HostingWebLanguagesEnum.js';
import { HostingWebFreedom } from '../models/HostingWebFreedom.js';
import { HostingWebOvhconfigContainerEnum } from '../models/HostingWebOvhconfigContainerEnum.js';
import { HostingWebOfferEnum } from '../models/HostingWebOfferEnum.js';
import { HostingWebRuntimeEnvEnum } from '../models/HostingWebRuntimeEnvEnum.js';
import { HostingWebDatabaseDump } from '../models/HostingWebDatabaseDump.js';
import OVHBase from '../ovh.js';
import '../models/HostingWebLocalSeoDirectory.js';
import '../models/HostingWebOwnLogsStatusEnum.js';
import '../models/HostingWebTaskObjectTypeEnum.js';
import '../models/HostingWebTaskStatusEnum.js';
import '../models/HostingWebLocalSeoLocationOfferEnum.js';
import '../models/HostingWebLocalSeoLocationStatusEnum.js';
import '../models/HostingWebDatabaseDatabaseIsolationEnum.js';
import '../models/HostingWebOfferCapabilitiesEnum.js';
import '../models/HostingWebConfigurationStateEnum.js';
import '../models/HostingWebConfigurationLanguageEnum.js';
import '../models/HostingWebConfigurationEnvEnum.js';
import '../models/HostingWebHostedsslTypeEnum.js';
import '../models/HostingWebHostedsslStatusEnum.js';
import '../models/HostingWebHostedsslProviderEnum.js';
import '../models/HostingWebHostedsslReportStatusEnum.js';
import '../models/HostingWebCronLanguageAvailable.js';
import '../models/HostingWebPhpVersionAvailableEnum.js';
import '../models/HostingWebNodejsVersionAvailableEnum.js';
import '../models/HostingWebPythonVersionAvailableEnum.js';
import '../models/HostingWebRubyVersionAvailableEnum.js';
import '../models/HostingWebHighLightEnum.js';
import '../models/HostingWebCreationEmailCapabilities.js';
import '../models/HostingWebDiskType.js';
import '../models/HostingWebDiskTypeEnum.js';
import '../models/HostingWebResourceEnum.js';
import '../models/HostingWebAvailableOfferStruct.js';
import '../models/OrderPrice.js';
import '../models/OrderCurrencyCodeEnum.js';
import '../models/HostingWebDatacenterEnum.js';
import '../models/HostingWebStateEnum.js';
import '../models/HostingWebPhpVersion.js';
import '../models/HostingWebPhpVersionStateEnum.js';
import '../models/HostingWebOperatingSystemEnum.js';
import '../models/HostingWebServiceAccess.js';
import '../models/HostingWebAddress.js';
import '../models/HostingWebCountriesIp.js';
import '../models/HostingWebCountryEnum.js';
import '../models/HostingWebUserStatusEnum.js';
import '../models/HostingWebUserStateEnum.js';
import '../models/HostingWebUserServiceCredentials.js';
import '../models/HostingWebUserCredentials.js';
import '../models/HostingWebRuntimeStateEnum.js';
import '../models/HostingWebCdnStatusEnum.js';
import '../models/HostingWebUserLogsStatusEnum.js';
import '../models/CdnDomainStatisticsNameEnum.js';
import '../models/CdnDomainStatisticsPoint.js';
import '../models/CdnDomainStatisticsUnitEnum.js';
import '../models/CdnOptionTypeEnum.js';
import '../models/CdnDomainOptionConfig.js';
import '../models/CdnOptionPatternTypeEnum.js';
import '../models/CdnOptionQueryParametersEnum.js';
import '../models/CdnDomainOptionExtra.js';
import '../models/HostingWebAttachedDomainCapabilities.js';
import '../models/HostingWebAttachedDomainMethodEnum.js';
import '../models/HostingWebAttachedDomainStatusEnum.js';
import '../models/HostingWebModuleStatusEnum.js';
import '../models/HostingWebModuleDependencyTypeEnum.js';
import '../models/ServiceStateEnum.js';
import '../models/ServiceRenewalTypeEnum.js';
import '../models/HostingWebMailStateEnum.js';
import '../models/CdnAvailableOptionsConfig.js';
import '../models/CdnAvailableOptionsConfigConstraints.js';
import '../models/CdnOptionConfigParamTypeEnum.js';
import '../models/CdnOptionCategoryEnum.js';
import '../models/HostingWebTaskFunctionEnum.js';
import '../models/HostingWebLocalSeoListingStatusEnum.js';
import '../models/HostingWebLocalSeoFlowStatusEnum.js';
import '../models/HostingWebLocalSeoFieldStatusEnum.js';
import '../models/HostingWebCronStateEnum.js';
import '../models/HostingWebCronStatusEnum.js';
import '../models/HostingWebDatabaseDumpStatusEnum.js';
import '../models/HostingWebModuleBranchEnum.js';
import '../models/HostingWebModuleAdminNameTypeEnum.js';
import '../models/HostingWebOvhConfigEngineVersionEnum.js';
import '../models/HostingWebOvhConfigStatusEnum.js';
import '../models/HostingWebEnvVarStatusEnum.js';
import '../models/HostingWebLocalSeoSearchData.js';
import '../models/CdnOptionTypePostEnum.js';
import '../models/HostingWebDatabaseModeEnum.js';
import '../models/HostingWebDatabaseStatusEnum.js';
import '../models/HostingWebDatabaseStateEnum.js';
import '../models/HostingWebDatabaseSupportedVersionEnum.js';
import '../models/CdnDomainStatusEnum.js';
import '../models/HostingWebLocalSeoAccountEmailAvailabilityEnum.js';
import '../models/HostingWebLocalSeoAccountStatusEnum.js';
import '../models/CdnOperationParameter.js';
import '../models/CdnOperationOfferEnum.js';
import '../models/CdnOperationStatusEnum.js';
import '../models/CdnOperationFunctionEnum.js';
import '../models/HostingWebFreedomStatusEnum.js';
import '../endpoints.js';

declare class HostingWebHandler {
    ovh: OVHBase;
    constructor(ovh: OVHBase);
    /** List available services */
    listWeb: () => Promise<string[]>;
    /** Find hosting service linked to a domain */
    getWebAttachedDomain: () => Promise<string[]>;
    /** Get available offer */
    getWebAvailableOffer: () => Promise<HostingWebOfferEnum[]>;
    /** Get current incident */
    getWebIncident: () => Promise<string[]>;
    /** Get list of directories associated to a local SEO offer and a country */
    getWebLocalSeoDirectoriesList: () => Promise<HostingWebLocalSeoDirectoriesList>;
    /** Check email availability for a local SEO order */
    checkWebLocalSeoEmailAvailability: () => Promise<HostingWebLocalSeoEmailAvailability>;
    /** Check visibility of a location */
    checkWebLocalSeoVisibility: (body: {
        country: HostingWebLocalSeoLocationCountryEnum;
        name: string;
        street: string;
        zip: string;
    }) => Promise<HostingWebLocalSeoVisibilityCheckResponse>;
    /** Get the result of a visibility check */
    getWebLocalSeoVisibilityCheckResult: () => Promise<HostingWebLocalSeoVisibilityCheckResultResponse[]>;
    /** IDs of all modules available */
    getWebModuleList: () => Promise<number[]>;
    /** Get this object properties */
    getWebModuleListById: (id: number) => Promise<HostingWebModuleList>;
    /** Get offer capabilities */
    getWebOfferCapabilities: () => Promise<HostingWebCapabilities>;
    /** Get this object properties */
    getWebByServiceName: (serviceName: string) => Promise<HostingWebService>;
    /** Alter this object properties */
    updateWebByServiceName: (serviceName: string, body: HostingWebService) => Promise<void>;
    /** Activate an included private database on your hosting offer */
    postWebActivatePrivateDatabaseByServiceName: (serviceName: string, body: {
        ram: HostingPrivateDatabaseAvailableRamSizeEnum;
        version: HostingPrivateDatabaseOrderableVersionEnum;
    }) => Promise<HostingWebTask>;
    /** Domains or subdomains attached to your hosting */
    getWebAttachedDomainByServiceName: (serviceName: string) => Promise<string[]>;
    /** Link a domain to this hosting */
    postWebAttachedDomainByServiceName: (serviceName: string, body: {
        cdn?: HostingWebAttachedDomainCdnEnum;
        domain: string;
        firewall?: HostingWebAttachedDomainFirewallEnum;
        ownLog?: string;
        path: string;
        runtimeId?: number;
        ssl?: boolean;
    }) => Promise<HostingWebTask>;
    /** Unlink domain from hosting */
    deleteWebAttachedDomainByServiceNameAndDomain: (domain: string, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebAttachedDomainByServiceNameAndDomain: (domain: string, serviceName: string) => Promise<HostingWebAttachedDomain>;
    /** Alter this object properties */
    updateWebAttachedDomainByServiceNameAndDomain: (domain: string, serviceName: string, body: HostingWebAttachedDomain) => Promise<void>;
    /** Purge cache for this attached domain */
    postWebAttachedDomainPurgeCacheByServiceNameAndDomain: (domain: string, serviceName: string) => Promise<HostingWebTask>;
    /** Restart the virtual host of the attached domain */
    postWebAttachedDomainRestartByServiceNameAndDomain: (domain: string, serviceName: string) => Promise<HostingWebTask>;
    /** List configurations available for current hosting */
    listWebAvailableConfigurationsByServiceName: (serviceName: string) => Promise<HostingWebConfigurationVersionEnum[]>;
    /** History of your hosting boost */
    getWebBoostHistoryByServiceName: (serviceName: string) => Promise<Date[]>;
    /** Get this object properties */
    getWebBoostHistoryByServiceNameAndDate: (date: Date, serviceName: string) => Promise<HostingWebBoostHistory>;
    /** Get this object properties */
    getWebCdnByServiceName: (serviceName: string) => Promise<HostingWebCdn>;
    /** List available options for a Shared CDN service */
    listWebCdnAvailableOptionsByServiceName: (serviceName: string) => Promise<CdnAvailableOptions[]>;
    /** List all domains for a Shared CDN service */
    listWebCdnDomainByServiceName: (serviceName: string) => Promise<CdnDomain[]>;
    /** Get details for a domain on a Shared CDN service */
    getWebCdnDomainByServiceNameAndDomainName: (serviceName: string, domainName: string) => Promise<CdnDomain>;
    /** Generate URL to logs archive */
    getWebCdnDomainLogsByServiceNameAndDomainName: (serviceName: string, domainName: string) => Promise<CdnLogs>;
    /** List all options for a domain */
    listWebCdnDomainOptionByServiceNameAndDomainName: (serviceName: string, domainName: string) => Promise<CdnDomainOption[]>;
    /** Add an option on a domain */
    addWebCdnDomainOptionByServiceNameAndDomainName: (serviceName: string, domainName: string, body: CdnDomainAddOption) => Promise<CdnDomainOption>;
    /** Remove or Reset an option to his default value */
    deleteWebCdnDomainOptionByServiceNameAndDomainNameAndOptionName: (serviceName: string, domainName: string, optionName: string) => Promise<void>;
    /** Get details for an option on a domain */
    getWebCdnDomainOptionByServiceNameAndDomainNameAndOptionName: (serviceName: string, domainName: string, optionName: string) => Promise<CdnDomainOption>;
    /** Update an option on a domain */
    updateWebCdnDomainOptionByServiceNameAndDomainNameAndOptionName: (serviceName: string, domainName: string, optionName: string, body: CdnDomainOption) => Promise<CdnDomainOption>;
    /** Flush cache content on CDN for a domain */
    postWebCdnDomainPurgeByServiceNameAndDomainName: (serviceName: string, domainName: string) => Promise<CdnOperation>;
    /** Trigger a refresh for a domain */
    postWebCdnDomainRefreshByServiceNameAndDomainName: (serviceName: string, domainName: string) => Promise<CdnOperation>;
    /** Get CDN statistics for a domain */
    getWebCdnDomainStatisticsByServiceNameAndDomainName: (serviceName: string, domainName: string) => Promise<CdnDomainStatistics[]>;
    /** List all operations for a Shared CDN service */
    listWebCdnOperationByServiceName: (serviceName: string) => Promise<CdnOperation[]>;
    /** Get details for a Shared CDN operation */
    getWebCdnOperationByServiceNameAndId: (serviceName: string, id: number) => Promise<CdnOperation>;
    /** Get this object properties */
    getWebCdnServiceInfosByServiceName: (serviceName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateWebCdnServiceInfosUpdateByServiceName: (serviceName: string, body: {
        renew: ServiceRenewType;
    }) => Promise<void>;
    /** Terminate your cdn sub service */
    postWebCdnTerminateByServiceName: (serviceName: string) => Promise<string>;
    /** Launch a contact change procedure */
    launchWebChangeContactByServiceName: (serviceName: string, body: {
        contactAdmin?: string;
        contactBilling?: string;
        contactTech?: string;
    }) => Promise<number[]>;
    /** Get this object properties */
    getWebConfigurationByServiceName: (serviceName: string) => Promise<HostingWebConfiguration>;
    /** Alter this object properties */
    updateWebConfigurationByServiceName: (serviceName: string, body: HostingWebConfiguration) => Promise<void>;
    /** Confirm termination of your service */
    confirmWebTerminationByServiceName: (serviceName: string, body: {
        commentary?: string;
        futureUse?: ServiceTerminationFutureUseEnum;
        reason?: ServiceTerminationReasonEnum;
        token: string;
    }) => Promise<string>;
    /** Crons on your webhosting */
    getWebCronByServiceName: (serviceName: string) => Promise<number[]>;
    /** Create new cron */
    createWebCronByServiceName: (serviceName: string, body: HostingWebCron) => Promise<HostingWebPublicTask>;
    /** Delete cron */
    deleteWebCronByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebPublicTask>;
    /** Get cron by id */
    getWebCronByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebCron>;
    /** Update cron */
    updateWebCronByServiceNameAndId: (id: number, serviceName: string, body: HostingWebCron) => Promise<string>;
    /** Get the list of supported languages by web domain */
    getWebCronAvailableLanguageByServiceName: (serviceName: string) => Promise<HostingWebLanguagesEnum[]>;
    /** Databases linked to your hosting */
    getWebDatabaseByServiceName: (serviceName: string) => Promise<string[]>;
    /** Install new database */
    postWebDatabaseByServiceName: (serviceName: string, body: {
        capabilitie: HostingWebDatabaseDatabaseCapabilitiesTypeEnum;
        password?: string;
        quota?: HostingWebDatabaseExtraSqlQuotaEnum;
        type: HostingWebDatabaseDatabaseCreationTypeEnum;
        user: string;
        version?: HostingWebDatabaseVersionEnum;
    }) => Promise<HostingWebTask>;
    /** Delete database */
    deleteWebDatabaseByServiceNameAndName: (name: string, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebDatabaseByServiceNameAndName: (name: string, serviceName: string) => Promise<HostingWebDatabase>;
    /** Get available capabilities for this database */
    getWebDatabaseCapabilitiesByServiceNameAndName: (name: string, serviceName: string) => Promise<HostingWebDatabaseDatabaseCapabilities>;
    /** Request a password change */
    postWebDatabaseChangePasswordByServiceNameAndName: (name: string, serviceName: string, body: {
        password: string;
    }) => Promise<HostingWebTask>;
    /** Dump available for your databases */
    getWebDatabaseDumpByServiceNameAndName: (name: string, serviceName: string) => Promise<number[]>;
    /** Request the dump from your database */
    postWebDatabaseDumpByServiceNameAndName: (name: string, serviceName: string, body: {
        date: HostingWebDatabaseDumpDateEnum;
        sendEmail?: boolean;
    }) => Promise<HostingWebTask>;
    /** Delete dump before expiration date */
    deleteWebDatabaseDumpByServiceNameAndNameAndId: (id: number, name: string, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebDatabaseDumpByServiceNameAndNameAndId: (id: number, name: string, serviceName: string) => Promise<HostingWebDatabaseDump>;
    /** Request the restore from this dump */
    postWebDatabaseDumpRestoreByServiceNameAndNameAndId: (id: number, name: string, serviceName: string) => Promise<HostingWebTask>;
    /** Import a dump from an specific file uploaded with /me/documents */
    postWebDatabaseImportByServiceNameAndName: (name: string, serviceName: string, body: {
        documentId: string;
        flushDatabase?: boolean;
        sendEmail?: boolean;
    }) => Promise<HostingWebTask>;
    /** Request specific operation for your database */
    postWebDatabaseRequestByServiceNameAndName: (name: string, serviceName: string, body: {
        action: HostingWebDatabaseRequestActionEnum;
    }) => Promise<HostingWebTask>;
    /** Request the restore from your database backup */
    postWebDatabaseRestoreByServiceNameAndName: (name: string, serviceName: string, body: {
        date: HostingWebDatabaseDumpDateEnum;
        sendEmail?: boolean;
    }) => Promise<HostingWebTask>;
    /** Get statistics about this database */
    getWebDatabaseStatisticsByServiceNameAndName: (name: string, serviceName: string) => Promise<ComplexTypeChartTimestampValue>;
    /** List available database type */
    listWebDatabaseAvailableTypeByServiceName: (serviceName: string) => Promise<HostingWebDatabaseDatabaseTypeEnum[]>;
    /** List available database version following a type */
    listWebDatabaseAvailableVersionByServiceName: (serviceName: string) => Promise<HostingWebDatabaseAvailableVersionStruct>;
    /** List available database you can install */
    listWebDatabaseCreationCapabilitiesByServiceName: (serviceName: string) => Promise<HostingWebDatabaseCreationDatabaseCapabilities[]>;
    /** Dumps linked to your hosting */
    getWebDumpByServiceName: (serviceName: string) => Promise<number[]>;
    /** Delete dump before expiration date */
    deleteWebDumpByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebDumpByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebDump>;
    /** Get this object properties */
    getWebEmailByServiceName: (serviceName: string) => Promise<HostingWebEmail>;
    /** Alter this object properties */
    updateWebEmailByServiceName: (serviceName: string, body: HostingWebEmail) => Promise<void>;
    /** Request the last bounces */
    getWebEmailBouncesByServiceName: (serviceName: string) => Promise<HostingWebMailBounce[]>;
    /** Request specific operation for your email */
    postWebEmailRequestByServiceName: (serviceName: string, body: {
        action: HostingWebMailActionEnum;
    }) => Promise<string>;
    /** Request the history volume of email sent */
    getWebEmailVolumesByServiceName: (serviceName: string) => Promise<HostingWebMailVolumeHistory[]>;
    /** Mail service linked to webhosting */
    getWebEmailOptionByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getWebEmailOptionByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebEmailoption>;
    /** Get the service properties */
    getWebEmailOptionServiceInfosByServiceNameAndId: (id: number, serviceName: string) => Promise<ServicesService>;
    /** Terminate your email sub service */
    postWebEmailOptionTerminateByServiceNameAndId: (id: number, serviceName: string) => Promise<string>;
    /** Environment variables set on your webhosting */
    getWebEnvVarByServiceName: (serviceName: string) => Promise<string[]>;
    /** Set a variable to this hosting */
    postWebEnvVarByServiceName: (serviceName: string, body: {
        key: string;
        type: HostingWebEnvVarTypeEnum;
        value: string;
    }) => Promise<HostingWebTask>;
    /** Remove variable from hosting */
    deleteWebEnvVarByServiceNameAndKey: (key: string, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebEnvVarByServiceNameAndKey: (key: string, serviceName: string) => Promise<HostingWebEnvVar>;
    /** Alter this object properties */
    updateWebEnvVarByServiceNameAndKey: (key: string, serviceName: string, body: HostingWebEnvVar) => Promise<void>;
    /** Sqlperso linked to your hosting */
    getWebExtraSqlPersoByServiceName: (serviceName: string) => Promise<string[]>;
    /** Get this object properties */
    getWebExtraSqlPersoByServiceNameAndName: (name: string, serviceName: string) => Promise<HostingWebExtrasqlperso>;
    /** Get databases linked with this option */
    getWebExtraSqlPersoDatabasesByServiceNameAndName: (name: string, serviceName: string) => Promise<string[]>;
    /** Get this object properties */
    getWebExtraSqlPersoServiceInfosByServiceNameAndName: (name: string, serviceName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateWebExtraSqlPersoServiceInfosUpdateByServiceNameAndName: (name: string, serviceName: string, body: {
        renew: ServiceRenewType;
    }) => Promise<void>;
    /** Terminate your extraSqlPerso sub service */
    postWebExtraSqlPersoTerminateByServiceNameAndName: (name: string, serviceName: string) => Promise<string>;
    /** Freedom linked to this hosting account */
    getWebFreedomByServiceName: (serviceName: string) => Promise<string[]>;
    /** Delete the freedom */
    deleteWebFreedomByServiceNameAndDomain: (domain: string, serviceName: string) => Promise<void>;
    /** Get this object properties */
    getWebFreedomByServiceNameAndDomain: (domain: string, serviceName: string) => Promise<HostingWebFreedom>;
    /** User of multidomain independent allowed on your hosting */
    getWebIndyByServiceName: (serviceName: string) => Promise<string[]>;
    /** Get this object properties */
    getWebIndyByServiceNameAndLogin: (login: string, serviceName: string) => Promise<HostingWebIndy>;
    /** Local SEO accounts associated to the hosting */
    getWebLocalSeoAccountByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getWebLocalSeoAccountByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebLocalSeoAccount>;
    /** Login this location for SSO */
    postWebLocalSeoAccountLoginByServiceNameAndId: (id: number, serviceName: string) => Promise<string>;
    /** Check email availability for a local SEO order */
    checkWebLocalSeoEmailAvailabilityByServiceName: (serviceName: string) => Promise<HostingWebLocalSeoEmailAvailability>;
    /** Local SEO locations associated to the hosting */
    getWebLocalSeoLocationByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getWebLocalSeoLocationByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebLocalSeoLocation>;
    /** Get this object properties */
    getWebLocalSeoLocationServiceInfosByServiceNameAndId: (id: number, serviceName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateWebLocalSeoLocationServiceInfosUpdateByServiceNameAndId: (id: number, serviceName: string, body: {
        renew: ServiceRenewType;
    }) => Promise<void>;
    /** Terminate a local SEO sub service */
    postWebLocalSeoLocationTerminateByServiceNameAndId: (id: number, serviceName: string) => Promise<string>;
    /** Module installed on your hosting */
    getWebModuleByServiceName: (serviceName: string) => Promise<number[]>;
    /** Install a new module */
    postWebModuleByServiceName: (serviceName: string, body: {
        adminName?: string;
        adminPassword?: string;
        dependencies?: HostingWebModuleDependencyType[];
        domain?: string;
        language?: HostingWebModuleLanguageEnum;
        moduleId: number;
        path?: string;
    }) => Promise<HostingWebTask>;
    /** Delete a module installed */
    deleteWebModuleByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebModuleByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebModule>;
    /** Generate a new admin password for your module */
    postWebModuleChangePasswordByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebTask>;
    /** Configuration used on your hosting */
    getWebOvhConfigByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getWebOvhConfigByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebOvhConfig>;
    /** Apply a new configuration on this path */
    postWebOvhConfigChangeConfigurationByServiceNameAndId: (id: number, serviceName: string, body: {
        container?: HostingWebOvhconfigContainerEnum;
        engineName?: HostingWebOvhConfigEngineNameEnum;
        engineVersion?: HostingWebOvhConfigAvailableEngineVersionEnum;
        environment?: HostingWebOvhConfigEnvironmentEnum;
        httpFirewall?: HostingWebOvhConfigHttpFirewallEnum;
    }) => Promise<HostingWebTask>;
    /** Rollback to an old configuration */
    postWebOvhConfigRollbackByServiceNameAndId: (id: number, serviceName: string, body: {
        rollbackId: number;
    }) => Promise<HostingWebTask>;
    /** Get the list of versions and container image available on your hosting */
    getWebOvhConfigCapabilitiesByServiceName: (serviceName: string) => Promise<HostingWebOvhConfigCapabilities[]>;
    /** Get recommended values on ovhConfig file */
    getWebOvhConfigRecommendedValuesByServiceName: (serviceName: string) => Promise<HostingWebOvhConfigRecommendedValues>;
    /** Synchronize the configuration listing with content on your hosting */
    postWebOvhConfigRefreshByServiceName: (serviceName: string) => Promise<HostingWebTask>;
    /** Own Logs linked to your hosting */
    getWebOwnLogsByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getWebOwnLogsByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebOwnLogs>;
    /** User allowed to connect into your logs interface */
    getWebOwnLogsUserLogsByServiceNameAndId: (id: number, serviceName: string) => Promise<string[]>;
    /** Create new userLogs */
    createWebOwnLogsUserLogsByServiceNameAndId: (id: number, serviceName: string, body: {
        description: string;
        login: string;
        ownLogsId?: number;
        password: string;
    }) => Promise<string>;
    /** Delete the userLogs */
    deleteWebOwnLogsUserLogsByServiceNameAndIdAndLogin: (id: number, login: string, serviceName: string) => Promise<string>;
    /** Get this object properties */
    getWebOwnLogsUserLogsByServiceNameAndIdAndLogin: (id: number, login: string, serviceName: string) => Promise<HostingWebUserLogs>;
    /** Alter this object properties */
    updateWebOwnLogsUserLogsByServiceNameAndIdAndLogin: (id: number, login: string, serviceName: string, body: HostingWebUserLogs) => Promise<void>;
    /** Request a password change */
    postWebOwnLogsUserLogsChangePasswordByServiceNameAndIdAndLogin: (id: number, login: string, serviceName: string, body: {
        password: string;
    }) => Promise<string>;
    /** List available privateDatabase you can install */
    listWebPrivateDatabaseCreationCapabilitiesByServiceName: (serviceName: string) => Promise<HostingWebDatabaseCreationDatabaseCapabilities[]>;
    /** List linked privateDatabases */
    listWebPrivateDatabasesByServiceName: (serviceName: string) => Promise<string[]>;
    /** Request specific operation for your hosting */
    postWebRequestByServiceName: (serviceName: string, body: {
        action: HostingWebRequestActionEnum;
    }) => Promise<HostingWebTask>;
    /** Allows you to boost your offer. */
    postWebRequestBoostByServiceName: (serviceName: string, body: {
        offer?: HostingWebOfferEnum;
    }) => Promise<HostingWebTask>;
    /** Restore this snapshot ALL CURRENT DATA WILL BE REPLACED BY YOUR SNAPSHOT */
    postWebRestoreSnapshotByServiceName: (serviceName: string, body: {
        backup: HostingWebBackupTypeEnum;
    }) => Promise<HostingWebTask>;
    /** List of runtime configurations to your hosting */
    listWebRuntimeByServiceName: (serviceName: string) => Promise<number[]>;
    /** Request the creation of a new runtime configuration */
    postWebRuntimeByServiceName: (serviceName: string, body: {
        appBootstrap?: string;
        appEnv?: HostingWebRuntimeEnvEnum;
        attachedDomains?: string[];
        isDefault?: boolean;
        name?: string;
        publicDir?: string;
        type?: HostingWebRuntimeTypeEnum;
    }) => Promise<HostingWebTask>;
    /** Delete a runtime configuration of an hosting */
    deleteWebRuntimeByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebRuntimeByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebRuntime>;
    /** Alter this object properties */
    updateWebRuntimeByServiceNameAndId: (id: number, serviceName: string, body: HostingWebRuntime) => Promise<void>;
    /** Get the attached domains linked to this runtime configuration */
    getWebRuntimeAttachedDomainsByServiceNameAndId: (id: number, serviceName: string) => Promise<string[]>;
    /** List available runtime configurations available backend types */
    listWebRuntimeAvailableTypesByServiceName: (serviceName: string) => Promise<HostingWebRuntimeTypeEnum[]>;
    /** Get this object properties */
    getWebServiceInfosByServiceName: (serviceName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateWebServiceInfosByServiceName: (serviceName: string, body: ServicesService) => Promise<void>;
    /** Get hosted SSL properties */
    getWebSslByServiceName: (serviceName: string) => Promise<HostingWebSSL>;
    /** Delete the HostedSsl on your hosting */
    deleteWebSslByServiceName: (serviceName: string) => Promise<HostingWebSSL>;
    /** Create the free default HostedSsl OR import your proper SSL on your hosting */
    createWebSslByServiceName: (serviceName: string, body: {
        certificate?: string;
        chain?: string;
        key?: string;
    }) => Promise<HostingWebSSL>;
    /** Get list of domains linked to the hosted SSL */
    getWebSslDomainsByServiceName: (serviceName: string) => Promise<string[]>;
    /** Request the regeneration of your HostedSsl */
    postWebSslRegenerateByServiceName: (serviceName: string) => Promise<HostingWebSSL>;
    /** Get hosted SSL report properties */
    getWebSslReportByServiceName: (serviceName: string) => Promise<HostingWebSslReport>;
    /** Get statistics about this web hosting */
    getWebStatisticsByServiceName: (serviceName: string) => Promise<ComplexTypeChartTimestampValue>;
    /** Tasks attached to your hosting */
    getWebTasksByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get this object properties */
    getWebTasksByServiceNameAndId: (id: number, serviceName: string) => Promise<HostingWebTask>;
    /** Terminate your service */
    postWebTerminateByServiceName: (serviceName: string) => Promise<string>;
    /** Use to link an external domain. ( This token has to be insert into a TXT field on your dns zone with ovhcontrol subdomain ) */
    getWebTokenByServiceName: (serviceName: string) => Promise<string>;
    /** User allowed to connect into your hosting */
    getWebUserByServiceName: (serviceName: string) => Promise<string[]>;
    /** Create new ftp/ssh user */
    createWebUserByServiceName: (serviceName: string, body: {
        home: string;
        login: string;
        password: string;
        sshState?: HostingWebUserSshStateEnum;
    }) => Promise<HostingWebTask>;
    /** Delete ftp/ssh user */
    deleteWebUserByServiceNameAndLogin: (login: string, serviceName: string) => Promise<HostingWebTask>;
    /** Get this object properties */
    getWebUserByServiceNameAndLogin: (login: string, serviceName: string) => Promise<HostingWebUser>;
    /** Alter this object properties */
    updateWebUserByServiceNameAndLogin: (login: string, serviceName: string, body: HostingWebUser) => Promise<void>;
    /** Request a password change */
    postWebUserChangePasswordByServiceNameAndLogin: (login: string, serviceName: string, body: {
        password: string;
    }) => Promise<HostingWebTask>;
    /** User allowed to connect into your logs interface */
    getWebUserLogsByServiceName: (serviceName: string) => Promise<string[]>;
    /** Create new userLogs */
    createWebUserLogsByServiceName: (serviceName: string, body: {
        description: string;
        login: string;
        ownLogsId?: number;
        password: string;
    }) => Promise<string>;
    /** Delete the userLogs */
    deleteWebUserLogsByServiceNameAndLogin: (login: string, serviceName: string) => Promise<string>;
    /** Get this object properties */
    getWebUserLogsByServiceNameAndLogin: (login: string, serviceName: string) => Promise<HostingWebUserLogs>;
    /** Alter this object properties */
    updateWebUserLogsByServiceNameAndLogin: (login: string, serviceName: string, body: HostingWebUserLogs) => Promise<void>;
    /** Request a password change */
    postWebUserLogsChangePasswordByServiceNameAndLogin: (login: string, serviceName: string, body: {
        password: string;
    }) => Promise<string>;
    /** Get a temporary token to access the your web hosting logs interface */
    getWebUserLogsTokenByServiceName: (serviceName: string) => Promise<string>;
}

export { HostingWebHandler };