/// <reference types="bluebird" />
import { BaseProxy } from './BaseProxy';
import { IMap } from './IMap';
import * as Promise from 'bluebird';
import { Data } from '../serialization/Data';
import { EntryView } from '../core/EntryView';
import { IMapListener } from '../core/MapListener';
import { Predicate } from '../core/Predicate';
import { IdentifiedDataSerializable, Portable } from '../serialization/Serializable';
import { Aggregator } from '../aggregation/Aggregator';
import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
export declare class MapProxy<K, V> extends BaseProxy implements IMap<K, V> {
    aggregate<R>(aggregator: Aggregator<R>): Promise<R>;
    aggregateWithPredicate<R>(aggregator: Aggregator<R>, predicate: Predicate): Promise<R>;
    executeOnKeys(keys: K[], entryProcessor: IdentifiedDataSerializable | Portable): Promise<any[]>;
    executeOnKey(key: K, entryProcessor: IdentifiedDataSerializable | Portable): Promise<V>;
    protected executeOnKeyInternal(keyData: Data, proData: Data): Promise<V>;
    executeOnEntries(entryProcessor: IdentifiedDataSerializable | Portable, predicate?: Predicate): Promise<[K, V][]>;
    entrySetWithPredicate(predicate: Predicate): Promise<any[]>;
    keySetWithPredicate(predicate: Predicate): Promise<K[]>;
    valuesWithPredicate(predicate: Predicate): Promise<ReadOnlyLazyList<V>>;
    addEntryListenerWithPredicate(listener: IMapListener<K, V>, predicate: Predicate, key?: K, includeValue?: boolean): Promise<string>;
    containsKey(key: K): Promise<boolean>;
    protected containsKeyInternal(keyData: Data): Promise<boolean>;
    containsValue(value: V): Promise<boolean>;
    put(key: K, value: V, ttl?: number): Promise<V>;
    protected putInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>;
    putAll(pairs: [K, V][]): Promise<void>;
    protected putAllInternal(partitionsToKeysData: {
        [id: string]: [Data, Data][];
    }): Promise<void>;
    get(key: K): Promise<V>;
    protected getInternal(keyData: Data): Promise<V>;
    remove(key: K, value?: V): Promise<V>;
    protected removeInternal(keyData: Data, value?: V): Promise<V>;
    size(): Promise<number>;
    clear(): Promise<void>;
    isEmpty(): Promise<boolean>;
    getAll(keys: K[]): Promise<any[]>;
    protected getAllInternal(partitionsToKeys: {
        [id: string]: any;
    }, result?: any[]): Promise<[Data, Data][]>;
    delete(key: K): Promise<void>;
    protected deleteInternal(keyData: Data): Promise<void>;
    entrySet(): Promise<any[]>;
    evict(key: K): Promise<boolean>;
    protected evictInternal(keyData: Data): Promise<boolean>;
    evictAll(): Promise<void>;
    flush(): Promise<void>;
    lock(key: K, ttl?: number): Promise<void>;
    isLocked(key: K): Promise<boolean>;
    unlock(key: K): Promise<void>;
    forceUnlock(key: K): Promise<void>;
    keySet(): Promise<K[]>;
    loadAll(keys?: K[], replaceExistingValues?: boolean): Promise<void>;
    putIfAbsent(key: K, value: V, ttl?: number): Promise<V>;
    protected putIfAbsentInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>;
    putTransient(key: K, value: V, ttl?: number): Promise<void>;
    protected putTransientInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>;
    replace(key: K, newValue: V): Promise<V>;
    protected replaceInternal(keyData: Data, newValueData: Data): Promise<V>;
    replaceIfSame(key: K, oldValue: V, newValue: V): Promise<boolean>;
    protected replaceIfSameInternal(keyData: Data, oldValueData: Data, newValueData: Data): Promise<boolean>;
    set(key: K, value: V, ttl?: number): Promise<void>;
    protected setInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>;
    values(): Promise<ReadOnlyLazyList<V>>;
    getEntryView(key: K): Promise<EntryView<K, V>>;
    addIndex(attribute: string, ordered: boolean): Promise<void>;
    tryLock(key: K, timeout?: number, lease?: number): Promise<boolean>;
    tryPut(key: K, value: V, timeout: number): Promise<boolean>;
    protected tryPutInternal(keyData: Data, valueData: Data, timeout: number): Promise<boolean>;
    tryRemove(key: K, timeout: number): Promise<boolean>;
    protected tryRemoveInternal(keyData: Data, timeout: number): Promise<boolean>;
    private addEntryListenerInternal(listener, predicate, key, includeValue);
    addEntryListener(listener: IMapListener<K, V>, key?: K, includeValue?: boolean): Promise<string>;
    removeEntryListener(listenerId: string): Promise<boolean>;
    private createEntryListenerToKey(name, keyData, includeValue, flags);
    private createEntryListenerToKeyWithPredicate(name, keyData, predicateData, includeValue, flags);
    private createEntryListenerWithPredicate(name, predicateData, includeValue, flags);
    private createEntryListener(name, includeValue, flags);
    private checkNotPagingPredicate(v);
}