@celerispay/hazelcast-client 3.12.5

package/lib/proxy/ReplicatedMap.d.ts

@@ -0,0 +1,149 @@
+/// <reference types="long" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { EntryListener } from '../core/EntryListener';
+import { Predicate } from '../core/Predicate';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { DistributedObject } from '../DistributedObject';
+import { ArrayComparator } from '../util/ArrayComparator';
+import Long = require('long');
+export interface ReplicatedMap<K, V> extends DistributedObject {
+    /**
+     * Associates a given value to the specified key and replicates it to the
+     * cluster. If there is an old value, it will be replaced by the specified
+     * one and returned from the call.
+     *
+     * @param key key with which the specified value is to be associated.
+     * @param value value to be associated with the specified key.
+     * @param ttl milliseconds to be associated with the specified key-value pair.
+     * @return old value if there was any, `null` otherwise.
+     */
+    put(key: K, value: V, ttl?: Long | number): Promise<V>;
+    /**
+     * The clear operation wipes data out of the replicated maps.
+     * If some node fails on executing the operation, it is retried for at most
+     * 5 times (on the failing nodes only).
+     * @return
+     */
+    clear(): Promise<void>;
+    /**
+     * Returns the value to which the specified key is mapped, or null if this map
+     * contains no mapping for the key.
+     *
+     * If this map permits null values, then a return value of null does not
+     * necessarily indicate that the map contains no mapping for the key; it's also
+     * possible that the map explicitly maps the key to null. The #containsKey
+     * operation may be used to distinguish these two cases. This message is
+     * idempotent.
+     *
+     * @param key key to search for.
+     * @return value associated with the specified key.
+     */
+    get(key: K): Promise<V>;
+    /**
+     * Returns true if this map contains a mapping for the specified key. This message is idempotent.
+     *
+     * @param key key to search for.
+     * @return `true` if this map contains the specified key, `false` otherwise.
+     */
+    containsKey(key: K): Promise<boolean>;
+    /**
+     * Returns true if this map maps one or more keys to the specified value.
+     *
+     * @param value value to search for.
+     * @return `true` if the specified value is associated with at least one key.
+     */
+    containsValue(value: V): Promise<boolean>;
+    /**
+     * If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
+     * @return Returns the number of key-value mappings in this map.
+     */
+    size(): Promise<number>;
+    /**
+     * @return `true` if this map has no entries, `false` otherwise.
+     */
+    isEmpty(): Promise<boolean>;
+    /**
+     * Removes the mapping for a key from this map if it is present (optional operation).
+     * Returns the value to which this map previously associated the key,
+     * or null if the map contained no mapping for the key. If this map permits null values,
+     * then a return value of null does not necessarily indicate that the map contained
+     * no mapping for the key; it's also possible that the map explicitly mapped the key to null.
+     * The map will not contain a mapping for the specified key once the call returns.
+     *
+     * @param key key to remove.
+     * @return value associated with key, `null` if the key did not exist before.
+     */
+    remove(key: K): Promise<V>;
+    /**
+     * Copies all of the mappings from the specified key-value pairs array to this map
+     * (optional operation).
+     * The effect of this call is equivalent to that of calling put(Object,Object)
+     * put(k, v) on this map once for each mapping from key k to value v in the specified
+     * map. The behavior of this operation is undefined if the specified map is modified
+     * while the operation is in progress
+     *
+     * @param pairs
+     * @return
+     */
+    putAll(pairs: Array<[K, V]>): Promise<void>;
+    /**
+     * Returns a view of the key contained in this map.
+     *
+     * @return keys of this map as an array.
+     */
+    keySet(): Promise<K[]>;
+    /**
+     * @return a list of values contained in this map.
+     */
+    values(comparator?: ArrayComparator<V>): Promise<ReadOnlyLazyList<V>>;
+    /**
+     * @return Returns entries as an array of key-value pairs.
+     */
+    entrySet(): Promise<Array<[K, V]>>;
+    /**
+     * Adds an continuous entry listener for this map. The listener will be notified for
+     * map add/remove/update/evict events filtered by the given predicate.
+     *
+     * @param listener
+     * @param key
+     * @param predicate
+     * @param localOnly
+     * @return Registration id of the listener.
+     */
+    addEntryListenerToKeyWithPredicate(listener: EntryListener<K, V>, key: K, predicate: Predicate): Promise<string>;
+    /**
+     * Adds an continuous entry listener for this map. The listener will be notified for
+     * map add/remove/update/evict events filtered by the given predicate.
+     *
+     * @param listener
+     * @param predicate
+     * @return Registration id of the listener.
+     */
+    addEntryListenerWithPredicate(listener: EntryListener<K, V>, predicate: Predicate): Promise<string>;
+    /**
+     * Adds the specified entry listener for the specified key. The listener will be
+     * notified for all add/remove/update/evict events of the specified key only.
+     *
+     * @param listener
+     * @param key
+     * @return Registration id of the listener.
+     */
+    addEntryListenerToKey(listener: EntryListener<K, V>, key: K): Promise<string>;
+    /**
+     * Adds an entry listener for this map. The listener will be notified for all
+     * map add/remove/update/evict events.
+     *
+     * @param listener
+     * @return Registration id of the listener.
+     */
+    addEntryListener(listener: EntryListener<K, V>): Promise<string>;
+    /**
+     * Removes the specified entry listener. Returns silently if there was no such
+     * listener added before. This message is idempotent.
+     *
+     * @param listenerId
+     * @return `true` if remove operation is successful, `false` if unsuccessful or this listener did not exist.
+     */
+    removeEntryListener(listenerId: string): Promise<boolean>;
+}

package/lib/proxy/ReplicatedMap.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/proxy/ReplicatedMapProxy.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="long" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { EntryListener } from '../core/EntryListener';
+import { Predicate } from '../core/Predicate';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { ArrayComparator } from '../util/ArrayComparator';
+import { ReplicatedMap } from './ReplicatedMap';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+import Long = require('long');
+export declare class ReplicatedMapProxy<K, V> extends PartitionSpecificProxy implements ReplicatedMap<K, V> {
+    put(key: K, value: V, ttl?: Long | number): Promise<V>;
+    clear(): Promise<void>;
+    get(key: K): Promise<V>;
+    containsKey(key: K): Promise<boolean>;
+    containsValue(value: V): Promise<boolean>;
+    size(): Promise<number>;
+    isEmpty(): Promise<boolean>;
+    remove(key: K): Promise<V>;
+    putAll(pairs: Array<[K, V]>): Promise<void>;
+    keySet(): Promise<K[]>;
+    values(comparator?: ArrayComparator<V>): Promise<ReadOnlyLazyList<V>>;
+    entrySet(): Promise<Array<[K, V]>>;
+    addEntryListenerToKeyWithPredicate(listener: EntryListener<K, V>, key: K, predicate: Predicate): Promise<string>;
+    addEntryListenerWithPredicate(listener: EntryListener<K, V>, predicate: Predicate): Promise<string>;
+    addEntryListenerToKey(listener: EntryListener<K, V>, key: K): Promise<string>;
+    addEntryListener(listener: EntryListener<K, V>): Promise<string>;
+    removeEntryListener(listenerId: string): Promise<boolean>;
+    private addEntryListenerInternal(listener, predicate, key);
+    private createEntryListener(name);
+    private createEntryListenerToKey(name, keyData);
+    private createEntryListenerWithPredicate(name, predicateData);
+    private createEntryListenerToKeyWithPredicate(name, keyData, predicateData);
+}

package/lib/proxy/ReplicatedMapProxy.js

@@ -0,0 +1,256 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReplicatedMapAddEntryListenerCodec_1 = require("../codec/ReplicatedMapAddEntryListenerCodec");
+var ReplicatedMapAddEntryListenerToKeyCodec_1 = require("../codec/ReplicatedMapAddEntryListenerToKeyCodec");
+/* tslint:disable:max-line-length */
+var ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1 = require("../codec/ReplicatedMapAddEntryListenerToKeyWithPredicateCodec");
+var ReplicatedMapAddEntryListenerWithPredicateCodec_1 = require("../codec/ReplicatedMapAddEntryListenerWithPredicateCodec");
+var ReplicatedMapClearCodec_1 = require("../codec/ReplicatedMapClearCodec");
+var ReplicatedMapContainsKeyCodec_1 = require("../codec/ReplicatedMapContainsKeyCodec");
+var ReplicatedMapContainsValueCodec_1 = require("../codec/ReplicatedMapContainsValueCodec");
+var ReplicatedMapEntrySetCodec_1 = require("../codec/ReplicatedMapEntrySetCodec");
+var ReplicatedMapGetCodec_1 = require("../codec/ReplicatedMapGetCodec");
+var ReplicatedMapIsEmptyCodec_1 = require("../codec/ReplicatedMapIsEmptyCodec");
+var ReplicatedMapKeySetCodec_1 = require("../codec/ReplicatedMapKeySetCodec");
+var ReplicatedMapPutAllCodec_1 = require("../codec/ReplicatedMapPutAllCodec");
+var ReplicatedMapPutCodec_1 = require("../codec/ReplicatedMapPutCodec");
+var ReplicatedMapRemoveCodec_1 = require("../codec/ReplicatedMapRemoveCodec");
+var ReplicatedMapRemoveEntryListenerCodec_1 = require("../codec/ReplicatedMapRemoveEntryListenerCodec");
+var ReplicatedMapSizeCodec_1 = require("../codec/ReplicatedMapSizeCodec");
+var ReplicatedMapValuesCodec_1 = require("../codec/ReplicatedMapValuesCodec");
+var EventType_1 = require("../core/EventType");
+var EntryListener_1 = require("../core/EntryListener");
+var ReadOnlyLazyList_1 = require("../core/ReadOnlyLazyList");
+var Util_1 = require("../Util");
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var MapListener_1 = require("../core/MapListener");
+var ReplicatedMapProxy = /** @class */ (function (_super) {
+    __extends(ReplicatedMapProxy, _super);
+    function ReplicatedMapProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ReplicatedMapProxy.prototype.put = function (key, value, ttl) {
+        if (ttl === void 0) { ttl = 0; }
+        Util_1.assertNotNull(key);
+        Util_1.assertNotNull(value);
+        var valueData = this.toData(value);
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(ReplicatedMapPutCodec_1.ReplicatedMapPutCodec, keyData, keyData, valueData, ttl);
+    };
+    ReplicatedMapProxy.prototype.clear = function () {
+        return this.encodeInvokeOnRandomTarget(ReplicatedMapClearCodec_1.ReplicatedMapClearCodec);
+    };
+    ReplicatedMapProxy.prototype.get = function (key) {
+        Util_1.assertNotNull(key);
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(ReplicatedMapGetCodec_1.ReplicatedMapGetCodec, keyData, keyData);
+    };
+    ReplicatedMapProxy.prototype.containsKey = function (key) {
+        Util_1.assertNotNull(key);
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(ReplicatedMapContainsKeyCodec_1.ReplicatedMapContainsKeyCodec, keyData, keyData);
+    };
+    ReplicatedMapProxy.prototype.containsValue = function (value) {
+        Util_1.assertNotNull(value);
+        var valueData = this.toData(value);
+        return this.encodeInvoke(ReplicatedMapContainsValueCodec_1.ReplicatedMapContainsValueCodec, valueData);
+    };
+    ReplicatedMapProxy.prototype.size = function () {
+        return this.encodeInvoke(ReplicatedMapSizeCodec_1.ReplicatedMapSizeCodec);
+    };
+    ReplicatedMapProxy.prototype.isEmpty = function () {
+        return this.encodeInvoke(ReplicatedMapIsEmptyCodec_1.ReplicatedMapIsEmptyCodec);
+    };
+    ReplicatedMapProxy.prototype.remove = function (key) {
+        Util_1.assertNotNull(key);
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(ReplicatedMapRemoveCodec_1.ReplicatedMapRemoveCodec, keyData, keyData);
+    };
+    ReplicatedMapProxy.prototype.putAll = function (pairs) {
+        var pair;
+        var pairId;
+        var entries = [];
+        for (pairId in pairs) {
+            pair = pairs[pairId];
+            var keyData = this.toData(pair[0]);
+            var valueData = this.toData(pair[1]);
+            entries.push([keyData, valueData]);
+        }
+        return this.encodeInvokeOnRandomTarget(ReplicatedMapPutAllCodec_1.ReplicatedMapPutAllCodec, entries);
+    };
+    ReplicatedMapProxy.prototype.keySet = function () {
+        var toObject = this.toObject.bind(this);
+        return this.encodeInvoke(ReplicatedMapKeySetCodec_1.ReplicatedMapKeySetCodec).then(function (keySet) {
+            return keySet.map(toObject);
+        });
+    };
+    ReplicatedMapProxy.prototype.values = function (comparator) {
+        var _this = this;
+        var toObject = this.toObject.bind(this);
+        return this.encodeInvoke(ReplicatedMapValuesCodec_1.ReplicatedMapValuesCodec).then(function (valuesData) {
+            if (comparator) {
+                var desValues = valuesData.map(toObject);
+                return new ReadOnlyLazyList_1.ReadOnlyLazyList(desValues.sort(comparator), _this.client.getSerializationService());
+            }
+            return new ReadOnlyLazyList_1.ReadOnlyLazyList(valuesData, _this.client.getSerializationService());
+        });
+    };
+    ReplicatedMapProxy.prototype.entrySet = function () {
+        var toObject = this.toObject.bind(this);
+        return this.encodeInvoke(ReplicatedMapEntrySetCodec_1.ReplicatedMapEntrySetCodec).then(function (entrySet) {
+            return entrySet.map(function (entry) { return [toObject(entry[0]), toObject(entry[1])]; });
+        });
+    };
+    ReplicatedMapProxy.prototype.addEntryListenerToKeyWithPredicate = function (listener, key, predicate) {
+        return this.addEntryListenerInternal(listener, predicate, key);
+    };
+    ReplicatedMapProxy.prototype.addEntryListenerWithPredicate = function (listener, predicate) {
+        return this.addEntryListenerInternal(listener, predicate, undefined);
+    };
+    ReplicatedMapProxy.prototype.addEntryListenerToKey = function (listener, key) {
+        return this.addEntryListenerInternal(listener, undefined, key);
+    };
+    ReplicatedMapProxy.prototype.addEntryListener = function (listener) {
+        return this.addEntryListenerInternal(listener, undefined, undefined);
+    };
+    ReplicatedMapProxy.prototype.removeEntryListener = function (listenerId) {
+        return this.client.getListenerService().deregisterListener(listenerId);
+    };
+    ReplicatedMapProxy.prototype.addEntryListenerInternal = function (listener, predicate, key) {
+        var _this = this;
+        var toObject = this.toObject.bind(this);
+        /* tslint:disable-next-line:no-shadowed-variable */
+        var entryEventHandler = function (key, value, oldValue, mergingValue, event, uuid, numberOfAffectedEntries) {
+            var member = _this.client.getClusterService().getMember(uuid);
+            var name = _this.name;
+            key = toObject(key);
+            value = toObject(value);
+            oldValue = toObject(oldValue);
+            mergingValue = toObject(mergingValue);
+            var entryEvent = new EntryListener_1.EntryEvent(name, key, value, oldValue, mergingValue, member);
+            var mapEvent = new MapListener_1.MapEvent(name, numberOfAffectedEntries, member);
+            var entryEventToListenerMap = (_a = {},
+                _a[EventType_1.EventType.ADDED] = 'added',
+                _a[EventType_1.EventType.REMOVED] = 'removed',
+                _a[EventType_1.EventType.UPDATED] = 'updated',
+                _a[EventType_1.EventType.EVICTED] = 'evicted',
+                _a);
+            var mapEventToListenerMap = (_b = {},
+                _b[EventType_1.EventType.CLEAR_ALL] = 'mapCleared',
+                _b);
+            var entryEventMethod = entryEventToListenerMap[event];
+            var mapEventMethod = mapEventToListenerMap[event];
+            if (listener.hasOwnProperty(entryEventMethod)) {
+                listener[entryEventMethod].apply(null, [entryEvent]);
+            }
+            else if (listener.hasOwnProperty(mapEventMethod)) {
+                listener[mapEventMethod].apply(null, [mapEvent]);
+            }
+            var _a, _b;
+        };
+        var listenerHandler;
+        var codec;
+        if (key && predicate) {
+            var keyData = this.toData(key);
+            var predicateData = this.toData(predicate);
+            codec = this.createEntryListenerToKeyWithPredicate(this.name, keyData, predicateData);
+            listenerHandler = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.handle;
+        }
+        else if (key && !predicate) {
+            var keyData = this.toData(key);
+            codec = this.createEntryListenerToKey(this.name, keyData);
+            listenerHandler = ReplicatedMapAddEntryListenerToKeyCodec_1.ReplicatedMapAddEntryListenerToKeyCodec.handle;
+        }
+        else if (!key && predicate) {
+            var predicateData = this.toData(predicate);
+            codec = this.createEntryListenerWithPredicate(this.name, predicateData);
+            listenerHandler = ReplicatedMapAddEntryListenerWithPredicateCodec_1.ReplicatedMapAddEntryListenerWithPredicateCodec.handle;
+        }
+        else {
+            codec = this.createEntryListener(this.name);
+            listenerHandler = ReplicatedMapAddEntryListenerCodec_1.ReplicatedMapAddEntryListenerCodec.handle;
+        }
+        return this.client.getListenerService().registerListener(codec, function (m) {
+            listenerHandler(m, entryEventHandler, toObject);
+        });
+    };
+    ReplicatedMapProxy.prototype.createEntryListener = function (name) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return ReplicatedMapAddEntryListenerCodec_1.ReplicatedMapAddEntryListenerCodec.encodeRequest(name, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return ReplicatedMapAddEntryListenerCodec_1.ReplicatedMapAddEntryListenerCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return ReplicatedMapRemoveEntryListenerCodec_1.ReplicatedMapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    ReplicatedMapProxy.prototype.createEntryListenerToKey = function (name, keyData) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return ReplicatedMapAddEntryListenerToKeyCodec_1.ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest(name, keyData, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return ReplicatedMapAddEntryListenerToKeyCodec_1.ReplicatedMapAddEntryListenerToKeyCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return ReplicatedMapRemoveEntryListenerCodec_1.ReplicatedMapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    ReplicatedMapProxy.prototype.createEntryListenerWithPredicate = function (name, predicateData) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return ReplicatedMapAddEntryListenerWithPredicateCodec_1.ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest(name, predicateData, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return ReplicatedMapAddEntryListenerWithPredicateCodec_1.ReplicatedMapAddEntryListenerWithPredicateCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return ReplicatedMapRemoveEntryListenerCodec_1.ReplicatedMapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    ReplicatedMapProxy.prototype.createEntryListenerToKeyWithPredicate = function (name, keyData, predicateData) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(name, keyData, predicateData, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return ReplicatedMapRemoveEntryListenerCodec_1.ReplicatedMapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    return ReplicatedMapProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.ReplicatedMapProxy = ReplicatedMapProxy;

package/lib/proxy/Ringbuffer.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { OverflowPolicy } from '../core/OverflowPolicy';
+import { DistributedObject } from '../DistributedObject';
+import { ReadResultSet } from './ringbuffer/ReadResultSet';
+export interface Ringbuffer<E> extends DistributedObject {
+    /**
+     * @return capacity of this ringbuffer.
+     */
+    capacity(): Promise<Long>;
+    /**
+     * Returns the number of the items in this ringbuffer.
+     *
+     * If time-to-live was NOT configured for this ringbuffer,
+     * the size will always be equal to the capacity after the first loop is completed
+     * around the ring. This is because no items are getting removed and are overwritten instead.
+     *
+     * @return size of this ringbuffer.
+     */
+    size(): Promise<Long>;
+    /**
+     * Returns the tail sequence. The tail is the side of the ringbuffer at which the items are added.
+     *
+     * The initial value of the tail sequence is -1.
+     *
+     * @return tail sequence of this ringbuffer.
+     */
+    tailSequence(): Promise<Long>;
+    /**
+     * Returns the head sequence. The head is the side of the ringbuffer where the oldest items are found.
+     *
+     * If the ringbuffer is empty, the head will be one more than the tail.
+     *
+     * The initial value of the head is 0.
+     * @return head sequence of this ringbuffer.
+     */
+    headSequence(): Promise<Long>;
+    /**
+     * Returns the remaining capacity of this ringbuffer.
+     *
+     * The returned value could be stale as soon as it is returned.
+     *
+     * If the time-to-live was NOT set in the configuration,
+     * the remaining capacity will always be equal to the capacity.
+     * @return remaining capacity of this ringbuffer.
+     */
+    remainingCapacity(): Promise<Long>;
+    /**
+     * Adds an item to the tail of this ringbuffer. Overflow policy determines what will happen
+     * if there is no space left in this ringbuffer. If `OVERWRITE` was passed,
+     * the new item will overwrite the oldest one regardless of the configured time-to-live.
+     *
+     * In the case when FAIL was specified the add operation will keep failing until an oldest item in this
+     * ringbuffer will reach its time-to-live.
+     *
+     * The returned value is the sequence number of the added item. You can read the added item using this number.
+     *
+     * @param item the item to add.
+     * @param overflowPolicy overflow policy to be used.
+     * @return the sequence of the added item or -1 if the insert did not succeed.
+     */
+    add(item: E, overflowPolicy?: OverflowPolicy): Promise<Long>;
+    /**
+     * Adds all items in the specified array to the tail of this buffer. The behavior of this method is essentially
+     * the same as the one of the `add` method.
+     *
+     * The method does not guarantee that the inserted items will have contiguous sequence numbers.
+     * @param items items to be added
+     * @param overflowPolicy overflow policy to be used
+     * @return the sequence number of the last written item from the specified array
+     */
+    addAll(items: E[], overflowPolicy?: OverflowPolicy): Promise<Long>;
+    /**
+     * Reads a single item from this ringbuffer.
+     *
+     * If the sequence is equal to the current tail sequence plus one,
+     * this call will not return a response until an item is added.
+     * If it is more than that, an error will be thrown.
+     *
+     *
+     * Unlike queue's `take`, this method does not remove an item from the ringbuffer. This means that the same item
+     * can be read by multiple processes.
+     *
+     *
+     * @param sequence the sequence number of the item to read.
+     * @return the item that was read.
+     * @throws `RangeError`         if the sequence is:
+     *                              smaller then zero;
+     *                              smaller than {@link #headSequence()};
+     *                              more than {@link #tailSequence()} + 1
+     */
+    readOne(sequence: number | Long): Promise<E>;
+    /**
+     * Reads a batch of items from this ringbuffer.
+     * If the number of available items starting at `sequence` is smaller than `maxCount`,
+     * then this method will not wait for more items to arrive.
+     * Instead, available items will be returned.
+     *
+     * If there are less items available than `minCount`, then this call will not return a response until
+     * a necessary number of items becomes available.
+     *
+     * @param sequence sequence number of the first item to be read.
+     * @param minCount minimum number of items to be read.
+     * @param maxCount maximum number of items to be read.
+     * @throws `RangeError` if startSequence is smaller than 0
+     *                      or if startSequence larger than {@link #tailSequence()}
+     *                      or if minCount smaller than 0
+     *                      or if minCount larger than maxCount,
+     *                      or if maxCount larger than the capacity of the ringbuffer
+     *                      or if maxCount larger than 1000 (to prevent overload)
+     */
+    readMany(sequence: number | Long, minCount: number, maxCount: number): Promise<ReadResultSet<E>>;
+}

package/lib/proxy/Ringbuffer.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/proxy/SemaphoreProxy.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import { ISemaphore } from './ISemaphore';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+import Long = require('long');
+export declare class SemaphoreProxy extends PartitionSpecificProxy implements ISemaphore {
+    init(permits: number): Promise<boolean>;
+    acquire(permits?: number): Promise<void>;
+    availablePermits(): Promise<number>;
+    drainPermits(): Promise<number>;
+    reducePermits(reduction: number): Promise<void>;
+    release(permits?: number): Promise<void>;
+    tryAcquire(permits: number, timeout?: Long | number): Promise<boolean>;
+}