import type { Place, Point, Zone } from "../types/interface";
export declare const sleep: (milliSeconds: number) => Promise<unknown>;
export declare function assertPoint(point: unknown): asserts point is Point;
export declare function assertAngle(angle: unknown): asserts angle is number | undefined;
export declare function assertZone(zone: any): asserts zone is Zone;
export declare function assertNotEmptyArray<T>(value: T[] | undefined, name: string): asserts value is T[];
export declare const isLatLngLiteral: (value: any) => boolean;
export declare const isPlacesInclude: (places: Place[], place: Place) => boolean;
interface Defered<T> extends Promise<T> {
    state: "pending" | "fulfilled" | "rejected";
    resolve: (value: T | PromiseLike<T>) => void;
    reject: (reason?: any) => void;
}
export declare function defered<T>(): Defered<T>;
export declare const resettableSleep: (milliSeconds: number) => {
    sleepPromise: Defered<void>;
    reset: () => void;
};
export declare const pausableSleep: (milliSeconds: number) => {
    sleepPromise: Defered<void>;
    pause: () => void;
    restart: () => void;
};
export declare const createRunOnce: <P extends any[], R>(fn: (...args: P) => R) => (...args: P) => R;
export declare const createOneConcurrent: <P extends any[], R>(fn: (...args: P) => Promise<R>) => (...args: P) => Promise<R> | undefined;
export declare const createReadOnce: <T>(value: T) => () => T | undefined;
export declare const createAsyncNoFailNonNullable: <P extends any[], R>(fn: (...args: P) => Promise<R>, defaultValue: NonNullable<R>) => (...args: P) => Promise<NonNullable<R>>;
export declare const pipeTimeout: <P extends any[], R>(fn: (...args: P) => Promise<R>, defaultValue: R, timeout: number) => (...args: P) => Promise<R>;
export declare const retryUntilSuccess: <P extends any[], R>(fn: (...args: P) => Promise<R>) => (...args: P) => Promise<R>;
export declare const equalAssign: <T extends {
    [k: string]: any;
}>(base: T, target: T) => T;
export declare const assertAssingedBeforeUsed: () => never;
type PickFunctionalPropertyName<T, K extends keyof T = keyof T> = K extends any ? T[K] extends (...args: any) => any ? K : never : never;
type PickFunctionalProperty<T> = Pick<T, PickFunctionalPropertyName<T>>;
export declare const proxyFunctionalProperty: <T extends object>(target: T) => PickFunctionalProperty<T>;
export declare const createAbortable: (signal?: AbortSignal) => <F extends ((...args: any) => Promise<any>) | undefined>(fn: F) => F;
export type AbortSignalOption = {
    signal?: AbortSignal;
};
type AbortableOneConcurrentCreator<F extends (...args: any[]) => Promise<any>> = (signal: AbortSignal) => F;
export declare const createAbortableOneConcurrent: <F extends (...args: any[]) => Promise<any>>(creator: AbortableOneConcurrentCreator<F>, opt?: {
    silent?: boolean;
}) => {
    fn: F;
    abort: () => void;
};
export declare const AbortSignalAny: (signals: (AbortSignal | undefined)[]) => AbortSignal;
export declare const guid: () => string;
/**
 * 判断两个小数是否相等，以短的小数位数为准
 * @param {string|number} num1
 * @param {string|number} num2
 * @returns boolean
 */
export declare const isDecimalEqualByShort: (num1: string | number, num2: string | number) => boolean;
export {};