hazelcast-client/lib/HazelcastClient.d.ts

Hazelcast - open source In-Memory Data Grid - client for NodeJS

/// <reference types="bluebird" />
import { SerializationService } from './serialization/SerializationService';
import { InvocationService, ListenerService } from './invocation/InvocationService';
import { ClientConfig } from './Config';
import * as Promise from 'bluebird';
import { IMap } from './proxy/IMap';
import { ISet } from './proxy/ISet';
import { LifecycleService } from './LifecycleService';
import { DistributedObject } from './DistributedObject';
import { ClientInfo } from './ClientInfo';
import ClientConnectionManager = require('./invocation/ClientConnectionManager');
import ProxyManager = require('./proxy/ProxyManager');
import PartitionService = require('./PartitionService');
import ClusterService = require('./invocation/ClusterService');
import Heartbeat = require('./HeartbeatService');
import { IQueue } from './proxy/IQueue';
import { IList } from './proxy/IList';
import { ILock } from './proxy/ILock';
import { MultiMap } from './proxy/MultiMap';
import { IRingbuffer } from './proxy/IRingbuffer';
import { ITopic } from './proxy/topic/ITopic';
import { IReplicatedMap } from './proxy/IReplicatedMap';
import { ISemaphore } from './proxy/ISemaphore';
import { IAtomicLong } from './proxy/IAtomicLong';
export default class HazelcastClient {
    private config;
    private loggingService;
    private serializationService;
    private invocationService;
    private listenerService;
    private connectionManager;
    private partitionService;
    private clusterService;
    private lifecycleService;
    private proxyManager;
    private heartbeat;
    static newHazelcastClient(config?: ClientConfig): Promise<HazelcastClient>;
    constructor(config?: ClientConfig);
    private init();
    getLocalEndpoint(): ClientInfo;
    getDistributedObjects(): Promise<DistributedObject[]>;
    getMap<K, V>(name: string): IMap<K, V>;
    getSet<E>(name: string): ISet<E>;
    getLock(name: string): ILock;
    getQueue<E>(name: string): IQueue<E>;
    getList<E>(name: string): IList<E>;
    getMultiMap<K, V>(name: string): MultiMap<K, V>;
    getRingbuffer<E>(name: string): IRingbuffer<E>;
    getReliableTopic<E>(name: string): ITopic<E>;
    getReplicatedMap<K, V>(name: string): IReplicatedMap<K, V>;
    getAtomicLong(name: string): IAtomicLong;
    getSemaphore(name: string): ISemaphore;
    getConfig(): ClientConfig;
    getSerializationService(): SerializationService;
    getInvocationService(): InvocationService;
    getListenerService(): ListenerService;
    getConnectionManager(): ClientConnectionManager;
    getPartitionService(): PartitionService;
    getProxyManager(): ProxyManager;
    getClusterService(): ClusterService;
    getHeartbeat(): Heartbeat;
    getLifecycleService(): LifecycleService;
    addDistributedObjectListener(listenerFunc: Function): Promise<string>;
    removeDistributedObjectListener(listenerId: string): Promise<boolean>;
    shutdown(): void;
}