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

OVH API wrapper library for TypeScript

import { DomainWhoisObfuscatorFieldsEnum } from '../models/DomainWhoisObfuscatorFieldsEnum.js';
import { ZoneNamedResolutionFieldTypeEnum } from '../models/ZoneNamedResolutionFieldTypeEnum.js';
import { DomainZoneZoneRestorePoint } from '../models/DomainZoneZoneRestorePoint.js';
import { DomainNameServerFullNameServer } from '../models/DomainNameServerFullNameServer.js';
import { DomainConfigurationsContactTypeEnum } from '../models/DomainConfigurationsContactTypeEnum.js';
import { DomainContact } from '../models/DomainContact.js';
import { DomainZoneDnssec } from '../models/DomainZoneDnssec.js';
import { ServicesService } from '../models/ServicesService.js';
import { D as DomainConfigurationRulesRule } from '../DomainConfigurationRulesRule-cd9777e0.js';
import { DomainExtensionsExtensionsPricingAttributes } from '../models/DomainExtensionsExtensionsPricingAttributes.js';
import { ServiceTerminationFutureUseEnum } from '../models/ServiceTerminationFutureUseEnum.js';
import { DomainDnssecKey } from '../models/DomainDnssecKey.js';
import { DomainNameServerCreatePayload } from '../models/DomainNameServerCreatePayload.js';
import { DomainZoneZone } from '../models/DomainZoneZone.js';
import { DomainExtensionsExtension } from '../models/DomainExtensionsExtension.js';
import { ZoneRedirectionTypeEnum } from '../models/ZoneRedirectionTypeEnum.js';
import { DomainGlueRecordGlueRecord } from '../models/DomainGlueRecordGlueRecord.js';
import { DomainZoneRecord } from '../models/DomainZoneRecord.js';
import { DomainZoneDynHostLogin } from '../models/DomainZoneDynHostLogin.js';
import { DomainZoneTask } from '../models/DomainZoneTask.js';
import { DomainConfigurationRulesRuleData } from '../models/DomainConfigurationRulesRuleData.js';
import { ZoneStatus } from '../models/ZoneStatus.js';
import { DomainNameServerNameServerStatus } from '../models/DomainNameServerNameServerStatus.js';
import { DomainOption } from '../models/DomainOption.js';
import { DomainNameServerUpdatePayload } from '../models/DomainNameServerUpdatePayload.js';
import { DomainOutgoingTransferApprove } from '../models/DomainOutgoingTransferApprove.js';
import { DomainZoneRedirection } from '../models/DomainZoneRedirection.js';
import { ZoneCapabilities } from '../models/ZoneCapabilities.js';
import { DomainDataClaimNoticeClaimNotice } from '../models/DomainDataClaimNoticeClaimNotice.js';
import { ServiceRenewType } from '../models/ServiceRenewType.js';
import { DomainDomainOptionEnum } from '../models/DomainDomainOptionEnum.js';
import { DomainUkRegistrar } from '../models/DomainUkRegistrar.js';
import { DomainConfigurationsObfuscatedEmail } from '../models/DomainConfigurationsObfuscatedEmail.js';
import { DomainDomain } from '../models/DomainDomain.js';
import { DnssecKey } from '../models/DnssecKey.js';
import { DomainTask } from '../models/DomainTask.js';
import { DomainConfigurationsObfuscatedEmailRefreshPayload } from '../models/DomainConfigurationsObfuscatedEmailRefreshPayload.js';
import { DomainConfigurationsObfuscatedEmailUpdatePayload } from '../models/DomainConfigurationsObfuscatedEmailUpdatePayload.js';
import { ZoneResetRecord } from '../models/ZoneResetRecord.js';
import { DomainDataSmdSmdBody } from '../models/DomainDataSmdSmdBody.js';
import { DomainExtensionsRegistryConfigurationsRegistryConfigurations } from '../models/DomainExtensionsRegistryConfigurationsRegistryConfigurations.js';
import { DomainZoneSoa } from '../models/DomainZoneSoa.js';
import { DomainConfigurationsOptinUpdatePayload } from '../models/DomainConfigurationsOptinUpdatePayload.js';
import { DomainGlueRecordCreatePayload } from '../models/DomainGlueRecordCreatePayload.js';
import { DomainServiceOptions } from '../models/DomainServiceOptions.js';
import { ServiceTerminationReasonEnum } from '../models/ServiceTerminationReasonEnum.js';
import { DomainZoneDynHostRecord } from '../models/DomainZoneDynHostRecord.js';
import { DomainOwo } from '../models/DomainOwo.js';
import { DomainExtensionsExtensionsByCategory } from '../models/DomainExtensionsExtensionsByCategory.js';
import { DomainConfigurationsOptin } from '../models/DomainConfigurationsOptin.js';
import { DomainZoneOption } from '../models/DomainZoneOption.js';
import { DomainRulesOptin } from '../models/DomainRulesOptin.js';
import { DomainDataSmdSmd } from '../models/DomainDataSmdSmd.js';
import OVHBase from '../ovh.js';
import '../models/NichandleLanguageEnum.js';
import '../models/NichandleCountryEnum.js';
import '../models/NichandleLegalFormEnum.js';
import '../models/NichandleGenderEnum.js';
import '../models/DomainContactAddress.js';
import '../models/DnssecDnssecStatusEnum.js';
import '../models/ServiceStateEnum.js';
import '../models/ServiceRenewalTypeEnum.js';
import '../models/DomainConfigurationRulesTypeEnum.js';
import '../models/DomainConfigurationRulesContextEnum.js';
import '../models/DomainConfigurationRulesOperatorEnum.js';
import '../models/DnssecKeyFlagEnum.js';
import '../models/DnssecKeyAlgorithmEnum.js';
import '../models/DnssecKeyStatusEnum.js';
import '../models/DomainNameServerNameServer.js';
import '../models/DomainOperationStatusEnum.js';
import '../models/DomainData.js';
import '../models/DomainIsForEnum.js';
import '../models/DomainConfigurationRulesRuleExtraData.js';
import '../models/NichandleNichandle.js';
import '../models/NichandleCurrency.js';
import '../models/NichandleStateEnum.js';
import '../models/NichandleOvhSubsidiaryEnum.js';
import '../models/NichandleOvhCompanyEnum.js';
import '../models/DomainNameServerNameServerTypeEnum.js';
import '../models/DomainNameServerNameServerStateEnum.js';
import '../models/DomainDomainOptionStateEnum.js';
import '../models/DomainApproveTypeEnum.js';
import '../models/DomainDataClaimNoticeClaimNoticeTypeEnum.js';
import '../models/DomainDataClaimNoticeClaimNoticeDecision.js';
import '../models/DomainDataClaimNoticeContact.js';
import '../models/DomainDataClaimNoticeAddress.js';
import '../models/DomainDataClaimNoticeUDRP.js';
import '../models/DomainDataClaimNoticeClassification.js';
import '../models/DomainDataClaimNoticeCourtDecision.js';
import '../models/DomainConfigurationsObfuscationStatusEnum.js';
import '../models/DomainDomainNsTypeEnum.js';
import '../models/DomainDomainLockStatusEnum.js';
import '../models/DomainParentService.js';
import '../models/DomainParentServiceTypeEnum.js';
import '../models/DomainDomainSuspensionStateEnum.js';
import '../models/DomainOfferEnum.js';
import '../models/DomainDomainStateEnum.js';
import '../models/ZoneResettableNamedResolutionFieldTypeEnum.js';
import '../models/DomainExtensionsRegistryConfigurationsDomainRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsLabelDomainRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsLifecycleRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsCreateLifecycleRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsTransferLifecycleRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsRestoreLifecycleRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsRenewLifecycleRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsOrderLifecycleRegistryConfiguration.js';
import '../models/DomainExtensionsRegistryConfigurationsDNSRegistryConfiguration.js';
import '../models/DomainServiceOption.js';
import '../models/DomainExtensionsCategoryNameWithExtensions.js';
import '../models/DomainOptinFieldsEnum.js';
import '../models/DomainDataSmdSmdLabel.js';
import '../endpoints.js';

declare class DomainHandler {
    ovh: OVHBase;
    constructor(ovh: OVHBase);
    /** List available services */
    list: () => Promise<string[]>;
    /** Get configuration rule applied for a domain in a given action */
    getConfigurationRule: () => Promise<DomainConfigurationRulesRule>;
    /** Validate a rule data for a specified domain */
    validateConfigurationRuleCheck: (body: DomainConfigurationRulesRuleData) => Promise<void>;
    /** List all contacts */
    listContact: () => Promise<DomainContact[]>;
    /** Create a contact */
    createContact: (body: DomainContact) => Promise<DomainContact>;
    /** Get details about a contact */
    getContactByContactId: (contactId: number) => Promise<DomainContact>;
    /** Update a contact */
    updateContactByContactId: (contactId: number, body: DomainContact) => Promise<DomainContact>;
    /** Retrieve claim notices associated to a domain */
    getDataClaimNotice: () => Promise<DomainDataClaimNoticeClaimNotice>;
    /** List all the extensions for a specific country */
    listDataExtension: () => Promise<string[]>;
    /** List all SMD files */
    listDataSmd: () => Promise<DomainDataSmdSmd[]>;
    /** Create a SMD file */
    createDataSmd: (body: DomainDataSmdSmdBody) => Promise<DomainDataSmdSmd>;
    /** Delete a SMD file */
    deleteDataSmdBySmdId: (smdId: string) => Promise<void>;
    /** Get details about a SMD file */
    getDataSmdBySmdId: (smdId: string) => Promise<DomainDataSmdSmd>;
    /** Update a SMD file */
    updateDataSmdBySmdId: (smdId: string, body: DomainDataSmdSmdBody) => Promise<DomainDataSmdSmd>;
    /** List all extensions */
    listExtensions: () => Promise<string[]>;
    /** List extensions, grouped by category types (like 'thematic', 'geolocalization') and category names (like 'europe') */
    listExtensionsByCategory: () => Promise<DomainExtensionsExtensionsByCategory>;
    /** List highlighted extensions, ordered by decreased importance */
    listExtensionsHighlighted: () => Promise<string[]>;
    /** List extensions with their pricing attributes. It especially documents whether an extension has been implemented recently or whether the price has dropped */
    listExtensionsPricingAttributes: () => Promise<DomainExtensionsExtensionsPricingAttributes[]>;
    /** Get an extension */
    getExtensionsByName: (name: string) => Promise<DomainExtensionsExtension>;
    /** Retrieve registry configuration for an extension */
    getExtensionsRegistryConfigurationsByName: (name: string) => Promise<DomainExtensionsRegistryConfigurationsRegistryConfigurations>;
    /** List available services */
    listZone: () => Promise<string[]>;
    /** Get this object properties */
    getZoneByZoneName: (zoneName: string) => Promise<DomainZoneZone>;
    /** Zone capabilities */
    getZoneCapabilitiesByZoneName: (zoneName: string) => Promise<ZoneCapabilities>;
    /** Launch a contact change procedure */
    launchZoneChangeContactByZoneName: (zoneName: string, body: {
        contactAdmin?: string;
        contactBilling?: string;
        contactTech?: string;
    }) => Promise<number[]>;
    /** Confirm termination of your service */
    confirmZoneTerminationByZoneName: (zoneName: string, body: {
        commentary?: string;
        futureUse?: ServiceTerminationFutureUseEnum;
        reason?: ServiceTerminationReasonEnum;
        token: string;
    }) => Promise<string>;
    /** Disable Dnssec */
    disableZoneDnssecByZoneName: (zoneName: string) => Promise<void>;
    /** Get this object properties */
    getZoneDnssecByZoneName: (zoneName: string) => Promise<DomainZoneDnssec>;
    /** Enable Dnssec */
    enableZoneDnssecByZoneName: (zoneName: string) => Promise<void>;
    /** DynHost' logins */
    getZoneDynHostLoginByZoneName: (zoneName: string) => Promise<string[]>;
    /** Create a new DynHost login */
    createZoneDynHostLoginByZoneName: (zoneName: string, body: {
        loginSuffix: string;
        password: string;
        subDomain: string;
    }) => Promise<DomainZoneDynHostLogin>;
    /** Delete a DynHost login */
    deleteZoneDynHostLoginByZoneNameAndLogin: (login: string, zoneName: string) => Promise<void>;
    /** Get this object properties */
    getZoneDynHostLoginByZoneNameAndLogin: (login: string, zoneName: string) => Promise<DomainZoneDynHostLogin>;
    /** Alter this object properties */
    updateZoneDynHostLoginByZoneNameAndLogin: (login: string, zoneName: string, body: DomainZoneDynHostLogin) => Promise<void>;
    /** Change password of the DynHost login */
    updateZoneDynHostLoginPasswordByZoneNameAndLogin: (login: string, zoneName: string, body: {
        password: string;
    }) => Promise<void>;
    /** DynHost' records */
    getZoneDynHostRecordByZoneName: (zoneName: string) => Promise<number[]>;
    /** Create a new DynHost record (Don't forget to refresh the zone) */
    createZoneDynHostRecordByZoneName: (zoneName: string, body: {
        ip: string;
        subDomain?: string;
    }) => Promise<DomainZoneDynHostRecord>;
    /** Delete a DynHost record (Don't forget to refresh the zone) */
    deleteZoneDynHostRecordByZoneNameAndId: (id: number, zoneName: string) => Promise<void>;
    /** Get this object properties */
    getZoneDynHostRecordByZoneNameAndId: (id: number, zoneName: string) => Promise<DomainZoneDynHostRecord>;
    /** Alter this object properties */
    updateZoneDynHostRecordByZoneNameAndId: (id: number, zoneName: string, body: DomainZoneDynHostRecord) => Promise<void>;
    /** Export zone */
    exportZoneByZoneName: (zoneName: string) => Promise<string>;
    /** Zone restore points */
    getZoneHistoryByZoneName: (zoneName: string) => Promise<Date[]>;
    /** Get this object properties */
    getZoneHistoryByZoneNameAndCreationDate: (creationDate: Date, zoneName: string) => Promise<DomainZoneZoneRestorePoint>;
    /** Restore the DNS zone */
    postZoneHistoryRestoreByZoneNameAndCreationDate: (creationDate: Date, zoneName: string) => Promise<DomainZoneTask>;
    /** Import zone */
    postZoneImportByZoneName: (zoneName: string, body: {
        zoneFile: string;
    }) => Promise<DomainZoneTask>;
    /** List zone options */
    listZoneOptionByZoneName: (zoneName: string) => Promise<string[]>;
    /** Get this object properties */
    getZoneOptionByZoneNameAndName: (name: string, zoneName: string) => Promise<DomainZoneOption>;
    /** Get this object properties */
    getZoneOptionServiceInfosByZoneNameAndName: (name: string, zoneName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateZoneOptionServiceInfosByZoneNameAndName: (name: string, zoneName: string, body: {
        renew: ServiceRenewType;
    }) => Promise<void>;
    /** Records of the zone */
    getZoneRecordByZoneName: (zoneName: string) => Promise<number[]>;
    /** Create a new DNS record (Don't forget to refresh the zone) */
    createZoneRecordByZoneName: (zoneName: string, body: {
        fieldType: ZoneNamedResolutionFieldTypeEnum;
        subDomain?: string;
        target: string;
        ttl?: number;
    }) => Promise<DomainZoneRecord>;
    /** Delete a DNS record (Don't forget to refresh the zone) */
    deleteZoneRecordByZoneNameAndId: (id: number, zoneName: string) => Promise<void>;
    /** Get this object properties */
    getZoneRecordByZoneNameAndId: (id: number, zoneName: string) => Promise<DomainZoneRecord>;
    /** Alter this object properties */
    updateZoneRecordByZoneNameAndId: (id: number, zoneName: string, body: DomainZoneRecord) => Promise<void>;
    /** Redirections */
    getZoneRedirectionByZoneName: (zoneName: string) => Promise<number[]>;
    /** Create a new redirection (Don't forget to refresh the zone) */
    createZoneRedirectionByZoneName: (zoneName: string, body: {
        description?: string;
        keywords?: string;
        subDomain?: string;
        target: string;
        title?: string;
        type: ZoneRedirectionTypeEnum;
    }) => Promise<DomainZoneRedirection>;
    /** Delete a redirection (Don't forget to refresh the zone) */
    deleteZoneRedirectionByZoneNameAndId: (id: number, zoneName: string) => Promise<void>;
    /** Get this object properties */
    getZoneRedirectionByZoneNameAndId: (id: number, zoneName: string) => Promise<DomainZoneRedirection>;
    /** Alter this object properties */
    updateZoneRedirectionByZoneNameAndId: (id: number, zoneName: string, body: DomainZoneRedirection) => Promise<void>;
    /** Apply zone modification on DNS servers */
    postZoneRefreshByZoneName: (zoneName: string) => Promise<void>;
    /** Reset the DNS zone */
    postZoneResetByZoneName: (zoneName: string, body: {
        DnsRecords?: ZoneResetRecord[];
        minimized?: boolean;
    }) => Promise<void>;
    /** Get this object properties */
    getZoneServiceInfosByZoneName: (zoneName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateZoneServiceInfosByZoneName: (zoneName: string, body: ServicesService) => Promise<void>;
    /** Get this object properties */
    getZoneSoaByZoneName: (zoneName: string) => Promise<DomainZoneSoa>;
    /** Alter this object properties */
    updateZoneSoaByZoneName: (zoneName: string, body: DomainZoneSoa) => Promise<void>;
    /** Zone status */
    getZoneStatusByZoneName: (zoneName: string) => Promise<ZoneStatus>;
    /** Domain pending tasks */
    getZoneTaskByZoneName: (zoneName: string) => Promise<number[]>;
    /** Get this object properties */
    getZoneTaskByZoneNameAndId: (id: number, zoneName: string) => Promise<DomainZoneTask>;
    /** Accelerate the task */
    postZoneTaskAccelerateByZoneNameAndId: (id: number, zoneName: string) => Promise<void>;
    /** Cancel the task */
    postZoneTaskCancelByZoneNameAndId: (id: number, zoneName: string) => Promise<void>;
    /** Relaunch the task */
    postZoneTaskRelaunchByZoneNameAndId: (id: number, zoneName: string) => Promise<void>;
    /** Terminate your service */
    postZoneTerminateByZoneName: (zoneName: string) => Promise<string>;
    /** Get this object properties */
    getByServiceName: (serviceName: string) => Promise<DomainDomain>;
    /** Alter this object properties */
    updateByServiceName: (serviceName: string, body: DomainDomain) => Promise<void>;
    /** Return authInfo code if the domain is unlocked */
    getAuthInfoByServiceName: (serviceName: string) => Promise<string>;
    /** Launch a contact change procedure */
    launchChangeContactByServiceName: (serviceName: string, body: {
        contactAdmin?: string;
        contactBilling?: string;
        contactTech?: string;
    }) => Promise<number[]>;
    /** Retrieve obfuscated emails configuration */
    getConfigurationsObfuscatedEmailsByServiceName: (serviceName: string) => Promise<DomainConfigurationsObfuscatedEmail[]>;
    /** Save a new obfuscated emails configuration */
    putConfigurationsObfuscatedEmailsByServiceName: (serviceName: string, body: DomainConfigurationsObfuscatedEmailUpdatePayload) => Promise<DomainConfigurationsObfuscatedEmail[]>;
    /** Refresh an obfuscated emails configuration with new values */
    postConfigurationsObfuscatedEmailsRefreshByServiceName: (serviceName: string, body: DomainConfigurationsObfuscatedEmailRefreshPayload) => Promise<void>;
    /** Retrieve optin configuration */
    getConfigurationsOptinByServiceName: (serviceName: string) => Promise<DomainConfigurationsOptin[]>;
    /** Save a new optin configuration */
    putConfigurationsOptinByServiceName: (serviceName: string, body: DomainConfigurationsOptinUpdatePayload) => Promise<DomainConfigurationsOptin[]>;
    /** List of domain's DS Records */
    listDsRecordByServiceName: (serviceName: string) => Promise<number[]>;
    /** Update DS records */
    updateDsRecordByServiceName: (serviceName: string, body: {
        keys: DnssecKey[];
    }) => Promise<DomainTask>;
    /** Get this object properties */
    getDsRecordByServiceNameAndId: (id: number, serviceName: string) => Promise<DomainDnssecKey>;
    /** List of glue records */
    listGlueRecordByServiceName: (serviceName: string) => Promise<string[]>;
    /** Create a glue record */
    createGlueRecordByServiceName: (serviceName: string, body: DomainGlueRecordCreatePayload) => Promise<DomainTask>;
    /** Delete the glue record */
    deleteGlueRecordByServiceNameAndHost: (serviceName: string, host: string) => Promise<DomainTask>;
    /** Get this glue record */
    getGlueRecordByServiceNameAndHost: (serviceName: string, host: string) => Promise<DomainGlueRecordGlueRecord>;
    /** Update the glue record */
    updateGlueRecordByServiceNameAndHost: (serviceName: string, host: string, body: DomainGlueRecordGlueRecord) => Promise<DomainTask>;
    /** List of current name servers */
    listNameServerByServiceName: (serviceName: string) => Promise<number[]>;
    /** Add new name server */
    addNameServerByServiceName: (serviceName: string, body: DomainNameServerCreatePayload) => Promise<DomainTask>;
    /** Delete a name server */
    deleteNameServerByServiceNameAndId: (serviceName: string, id: number) => Promise<DomainTask>;
    /** Get this name server configuration */
    getNameServerByServiceNameAndId: (serviceName: string, id: number) => Promise<DomainNameServerFullNameServer>;
    /** Get name server status */
    getNameServerStatusByServiceNameAndId: (serviceName: string, id: number) => Promise<DomainNameServerNameServerStatus>;
    /** Get name server status */
    postNameServerStatusByServiceNameAndId: (serviceName: string, id: number) => Promise<DomainNameServerNameServerStatus>;
    /** Update DNS servers */
    updateNameServersByServiceName: (serviceName: string, body: DomainNameServerUpdatePayload) => Promise<DomainTask>;
    /** List domain options */
    listOptionByServiceName: (serviceName: string) => Promise<DomainDomainOptionEnum[]>;
    /** Remove a given option */
    deleteOptionByServiceNameAndOption: (serviceName: string, option: DomainDomainOptionEnum) => Promise<void>;
    /** Get details on this domain option */
    getOptionByServiceNameAndOption: (serviceName: string, option: DomainDomainOptionEnum) => Promise<DomainOption>;
    /** Retrieve data about the options associated to a domain */
    getOptionsByServiceName: (serviceName: string) => Promise<DomainServiceOptions>;
    /** Approve Outgoing Transfer for a domain */
    postOutgoingTransferApproveByServiceName: (serviceName: string, body: DomainOutgoingTransferApprove) => Promise<void>;
    /** List of whois obfuscators */
    listOwoByServiceName: (serviceName: string) => Promise<DomainWhoisObfuscatorFieldsEnum[]>;
    /** Add whois obfuscators */
    addOwoByServiceName: (serviceName: string, body: {
        fields: DomainWhoisObfuscatorFieldsEnum[];
    }) => Promise<DomainWhoisObfuscatorFieldsEnum[]>;
    /** Delete a whois obfuscator */
    deleteOwoByServiceNameAndField: (field: DomainWhoisObfuscatorFieldsEnum, serviceName: string) => Promise<void>;
    /** Get this object properties */
    getOwoByServiceNameAndField: (field: DomainWhoisObfuscatorFieldsEnum, serviceName: string) => Promise<DomainOwo>;
    /** Retrieve emails obfuscation rule */
    getRulesEmailsObfuscationByServiceName: (serviceName: string) => Promise<DomainConfigurationsContactTypeEnum[]>;
    /** Retrieve optin rule */
    getRulesOptinByServiceName: (serviceName: string) => Promise<DomainRulesOptin[]>;
    /** Get this object properties */
    getServiceInfosByServiceName: (serviceName: string) => Promise<ServicesService>;
    /** Alter this object properties */
    updateServiceInfosByServiceName: (serviceName: string, body: ServicesService) => Promise<void>;
    /** List all domain tasks */
    listTaskByServiceName: (serviceName: string) => Promise<number[]>;
    /** Get details about a domain task */
    getTaskByServiceNameAndId: (serviceName: string, id: number) => Promise<DomainTask>;
    /** Accelerate the task */
    postTaskAccelerateByServiceNameAndId: (serviceName: string, id: number) => Promise<void>;
    /** Cancel the task */
    postTaskCancelByServiceNameAndId: (serviceName: string, id: number) => Promise<void>;
    /** Relaunch the task */
    postTaskRelaunchByServiceNameAndId: (serviceName: string, id: number) => Promise<void>;
    /** Schedule an outgoing transfer task for this domain (.uk only) */
    postUkOutgoingTransferByServiceName: (serviceName: string, body: DomainUkRegistrar) => Promise<DomainTask>;
    /** Return the list of all .uk registrars */
    getUkRegistrarsByServiceName: (serviceName: string) => Promise<DomainUkRegistrar[]>;
}

export { DomainHandler };