import { Method } from 'axios';
export declare class PD {
    private token;
    private debug;
    private _me;
    private _domain;
    private progressState;
    silent: boolean;
    static isOldBearerToken(token: string): boolean;
    static isNewBearerToken(token: string): boolean;
    static isBearerToken(token: string): boolean;
    static isLegacyToken(token: string): boolean;
    static isValidToken(token: string): boolean;
    static authHeaderForToken(token: string): string;
    constructor(token: string, debug?: boolean);
    private _request;
    request(req: PD.Request): Promise<PD.Result<any>>;
    private requestWithIndex;
    me(): Promise<any>;
    domain(): Promise<string>;
    batchedRequest(requests: PD.Request[], p?: {
        batchSize?: number;
        callback?: PD.Callback;
        reportTotal?: boolean;
    }): Promise<PD.BatchResult>;
    private spinnerCallback;
    batchedRequestWithSpinner(requests: PD.Request[], p?: {
        batchSize?: number;
        activityDescription?: string;
        stopSpinnerWhenDone?: boolean;
    }): Promise<PD.BatchResult>;
    private static endpointIdentifier;
    fetch(endpoint: string, p?: {
        params?: object;
        headers?: object;
        method?: Method;
        data?: object;
        callback?: PD.Callback;
        fetchLimit?: number;
    }): Promise<any>;
    fetchWithSpinner(endpoint: string, p?: {
        params?: object;
        headers?: object;
        method?: Method;
        data?: object;
        activityDescription?: string;
        stopSpinnerWhenDone?: boolean;
        fetchLimit?: number;
    }): Promise<any[]>;
    private objectIDForName;
    private objectIDsForNames;
    businessServiceIDForName(name: string): Promise<string | null>;
    businessServiceIDsForNames(names: string[], exact?: boolean): Promise<string[]>;
    serviceIDForName(name: string): Promise<string | null>;
    serviceIDsForNames(names: string[], exact?: boolean): Promise<string[]>;
    scheduleIDForName(name: string): Promise<string | null>;
    scheduleIDsForNames(names: string[]): Promise<string[]>;
    epIDForName(name: string): Promise<string | null>;
    epIDsForNames(names: string[]): Promise<string[]>;
    userIDForEmail(email: string): Promise<string | null>;
    userIDsForEmails(emails: string[], exact?: boolean): Promise<string[]>;
    tagIDForName(name: string): Promise<string | null>;
    teamIDForName(name: string): Promise<string | null>;
    teamIDsForNames(names: string[]): Promise<string[]>;
    private getPrioritiesMapBy;
    getPrioritiesMapByName(): Promise<any>;
    getPrioritiesMapByID(): Promise<any>;
}
export declare namespace PD {
    interface Request {
        endpoint: string;
        method?: Method;
        params?: object;
        data?: object;
        headers?: object;
    }
    type Callback = (p: CallbackParams) => void;
    interface CallbackParams {
        start?: boolean;
        waiting?: boolean;
        success?: boolean;
        failure?: boolean;
        failureMessage?: string;
        total?: number;
        done?: boolean;
    }
    class BatchResult {
        requests: PD.Request[];
        results: PD.Result<any>[];
        isSuccess: boolean;
        constructor(requests: PD.Request[], results: PD.Result<any>[]);
        getValues(): any[];
        getDatas(): any[];
        getFailedIndices(): number[];
        getSucceededIndices(): number[];
    }
    class Error {
        errorObj: any;
        constructor(errorObj: any);
        get isDocumentedErrorType(): boolean;
        get formattedError(): string;
    }
    class Result<T> {
        isSuccess: boolean;
        isFailure: boolean;
        private value;
        private constructor();
        static ok<U>(value: U): PD.Result<U>;
        static fail<U>(error: U): PD.Result<U>;
        getData(): T | null;
        getValue(): T | null;
        getError(): T | null;
        getFormattedError(): string;
        statusCode(): number;
    }
}