@celerispay/hazelcast-client 3.12.5

package/lib/proxy/SemaphoreProxy.js

@@ -0,0 +1,73 @@
+"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 SemaphoreAcquireCodec_1 = require("../codec/SemaphoreAcquireCodec");
+var SemaphoreAvailablePermitsCodec_1 = require("../codec/SemaphoreAvailablePermitsCodec");
+var SemaphoreDrainPermitsCodec_1 = require("../codec/SemaphoreDrainPermitsCodec");
+var SemaphoreInitCodec_1 = require("../codec/SemaphoreInitCodec");
+var SemaphoreReducePermitsCodec_1 = require("../codec/SemaphoreReducePermitsCodec");
+var SemaphoreReleaseCodec_1 = require("../codec/SemaphoreReleaseCodec");
+var SemaphoreTryAcquireCodec_1 = require("../codec/SemaphoreTryAcquireCodec");
+var Util_1 = require("../Util");
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var SemaphoreProxy = /** @class */ (function (_super) {
+    __extends(SemaphoreProxy, _super);
+    function SemaphoreProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SemaphoreProxy.prototype.init = function (permits) {
+        Util_1.assertNotNegative(permits, 'Permits cannot be negative.');
+        return this.encodeInvoke(SemaphoreInitCodec_1.SemaphoreInitCodec, permits);
+    };
+    SemaphoreProxy.prototype.acquire = function (permits) {
+        if (permits === void 0) { permits = 1; }
+        Util_1.assertNotNegative(permits, 'Permits cannot be negative.');
+        return this.encodeInvoke(SemaphoreAcquireCodec_1.SemaphoreAcquireCodec, permits);
+    };
+    SemaphoreProxy.prototype.availablePermits = function () {
+        return this.encodeInvoke(SemaphoreAvailablePermitsCodec_1.SemaphoreAvailablePermitsCodec);
+    };
+    SemaphoreProxy.prototype.drainPermits = function () {
+        return this.encodeInvoke(SemaphoreDrainPermitsCodec_1.SemaphoreDrainPermitsCodec);
+    };
+    SemaphoreProxy.prototype.reducePermits = function (reduction) {
+        Util_1.assertNotNegative(reduction, 'Reduction cannot be negative.');
+        return this.encodeInvoke(SemaphoreReducePermitsCodec_1.SemaphoreReducePermitsCodec, reduction);
+    };
+    SemaphoreProxy.prototype.release = function (permits) {
+        if (permits === void 0) { permits = 1; }
+        Util_1.assertNotNegative(permits, 'Permits cannot be negative.');
+        return this.encodeInvoke(SemaphoreReleaseCodec_1.SemaphoreReleaseCodec, permits);
+    };
+    SemaphoreProxy.prototype.tryAcquire = function (permits, timeout) {
+        if (timeout === void 0) { timeout = 0; }
+        Util_1.assertNotNegative(permits, 'Permits cannot be negative.');
+        return this.encodeInvoke(SemaphoreTryAcquireCodec_1.SemaphoreTryAcquireCodec, permits, timeout);
+    };
+    return SemaphoreProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.SemaphoreProxy = SemaphoreProxy;

package/lib/proxy/SetProxy.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ItemListener } from '../core/ItemListener';
+import { ISet } from './ISet';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+export declare class SetProxy<E> extends PartitionSpecificProxy implements ISet<E> {
+    add(entry: E): Promise<boolean>;
+    addAll(items: E[]): Promise<boolean>;
+    toArray(): Promise<E[]>;
+    clear(): Promise<void>;
+    contains(entry: E): Promise<boolean>;
+    containsAll(items: E[]): Promise<boolean>;
+    isEmpty(): Promise<boolean>;
+    remove(entry: E): Promise<boolean>;
+    removeAll(items: E[]): Promise<boolean>;
+    retainAll(items: E[]): Promise<boolean>;
+    size(): Promise<number>;
+    addItemListener(listener: ItemListener<E>, includeValue?: boolean): Promise<string>;
+    removeItemListener(registrationId: string): Promise<boolean>;
+    private serializeList(input);
+    private createEntryListener(name, includeValue);
+}

package/lib/proxy/SetProxy.js

@@ -0,0 +1,130 @@
+"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 SetAddAllCodec_1 = require("../codec/SetAddAllCodec");
+var SetAddCodec_1 = require("../codec/SetAddCodec");
+var SetAddListenerCodec_1 = require("../codec/SetAddListenerCodec");
+var SetClearCodec_1 = require("../codec/SetClearCodec");
+var SetCompareAndRemoveAllCodec_1 = require("../codec/SetCompareAndRemoveAllCodec");
+var SetCompareAndRetainAllCodec_1 = require("../codec/SetCompareAndRetainAllCodec");
+var SetContainsAllCodec_1 = require("../codec/SetContainsAllCodec");
+var SetContainsCodec_1 = require("../codec/SetContainsCodec");
+var SetGetAllCodec_1 = require("../codec/SetGetAllCodec");
+var SetIsEmptyCodec_1 = require("../codec/SetIsEmptyCodec");
+var SetRemoveCodec_1 = require("../codec/SetRemoveCodec");
+var SetRemoveListenerCodec_1 = require("../codec/SetRemoveListenerCodec");
+var SetSizeCodec_1 = require("../codec/SetSizeCodec");
+var ItemListener_1 = require("../core/ItemListener");
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var SetProxy = /** @class */ (function (_super) {
+    __extends(SetProxy, _super);
+    function SetProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SetProxy.prototype.add = function (entry) {
+        return this.encodeInvoke(SetAddCodec_1.SetAddCodec, this.toData(entry));
+    };
+    SetProxy.prototype.addAll = function (items) {
+        return this.encodeInvoke(SetAddAllCodec_1.SetAddAllCodec, this.serializeList(items));
+    };
+    SetProxy.prototype.toArray = function () {
+        var _this = this;
+        return this.encodeInvoke(SetGetAllCodec_1.SetGetAllCodec).then(function (items) {
+            return items.map(function (item) {
+                return _this.toObject(item);
+            });
+        });
+    };
+    SetProxy.prototype.clear = function () {
+        return this.encodeInvoke(SetClearCodec_1.SetClearCodec);
+    };
+    SetProxy.prototype.contains = function (entry) {
+        return this.encodeInvoke(SetContainsCodec_1.SetContainsCodec, this.toData(entry));
+    };
+    SetProxy.prototype.containsAll = function (items) {
+        return this.encodeInvoke(SetContainsAllCodec_1.SetContainsAllCodec, this.serializeList(items));
+    };
+    SetProxy.prototype.isEmpty = function () {
+        return this.encodeInvoke(SetIsEmptyCodec_1.SetIsEmptyCodec);
+    };
+    SetProxy.prototype.remove = function (entry) {
+        return this.encodeInvoke(SetRemoveCodec_1.SetRemoveCodec, this.toData(entry));
+    };
+    SetProxy.prototype.removeAll = function (items) {
+        return this.encodeInvoke(SetCompareAndRemoveAllCodec_1.SetCompareAndRemoveAllCodec, this.serializeList(items));
+    };
+    SetProxy.prototype.retainAll = function (items) {
+        return this.encodeInvoke(SetCompareAndRetainAllCodec_1.SetCompareAndRetainAllCodec, this.serializeList(items));
+    };
+    SetProxy.prototype.size = function () {
+        return this.encodeInvoke(SetSizeCodec_1.SetSizeCodec);
+    };
+    SetProxy.prototype.addItemListener = function (listener, includeValue) {
+        var _this = this;
+        if (includeValue === void 0) { includeValue = true; }
+        var handler = function (message) {
+            SetAddListenerCodec_1.SetAddListenerCodec.handle(message, function (item, uuid, eventType) {
+                var responseObject = _this.toObject(item);
+                var member = _this.client.getClusterService().getMember(uuid);
+                var name = _this.name;
+                var itemEvent = new ItemListener_1.ItemEvent(name, eventType, responseObject, member);
+                if (eventType === ItemListener_1.ItemEventType.ADDED && listener.itemAdded) {
+                    listener.itemAdded.apply(null, [itemEvent]);
+                }
+                else if (eventType === ItemListener_1.ItemEventType.REMOVED && listener.itemRemoved) {
+                    listener.itemRemoved.apply(null, [itemEvent]);
+                }
+            });
+        };
+        var codec = this.createEntryListener(this.name, includeValue);
+        return this.client.getListenerService().registerListener(codec, handler);
+    };
+    SetProxy.prototype.removeItemListener = function (registrationId) {
+        return this.client.getListenerService().deregisterListener(registrationId);
+    };
+    SetProxy.prototype.serializeList = function (input) {
+        var _this = this;
+        return input.map(function (each) {
+            return _this.toData(each);
+        });
+    };
+    SetProxy.prototype.createEntryListener = function (name, includeValue) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return SetAddListenerCodec_1.SetAddListenerCodec.encodeRequest(name, includeValue, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return SetAddListenerCodec_1.SetAddListenerCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return SetRemoveListenerCodec_1.SetRemoveListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    return SetProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.SetProxy = SetProxy;

package/lib/proxy/flakeid/AutoBatcher.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="long" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+export declare class Batch {
+    private nextIdLong;
+    private increment;
+    private batchSize;
+    private invalidSince;
+    private firstInvalidId;
+    constructor(validityMillis: number, base: Long, increment: Long, batchSize: number);
+    /**
+     * @returns next id from the batch,
+     *          undefined if ids are exhausted or not valid anymore
+     */
+    nextId(): Long;
+}
+export declare class AutoBatcher {
+    private readonly NEW_BATCH_AVAILABLE;
+    private queue;
+    private batch;
+    private requestInFlight;
+    private supplier;
+    private emitter;
+    constructor(supplier: () => Promise<any>);
+    processIdRequests(): void;
+    nextId(): Promise<Long>;
+    private assignNewBatch();
+    private rejectAll(e);
+}

package/lib/proxy/flakeid/AutoBatcher.js

@@ -0,0 +1,104 @@
+"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 });
+var events_1 = require("events");
+var Util_1 = require("../../Util");
+var Batch = /** @class */ (function () {
+    function Batch(validityMillis, base, increment, batchSize) {
+        this.nextIdLong = base;
+        this.increment = increment;
+        this.firstInvalidId = base.add(this.increment.multiply(batchSize));
+        if (validityMillis > 0) {
+            this.invalidSince = validityMillis + Date.now();
+        }
+        else {
+            this.invalidSince = Number.MAX_SAFE_INTEGER;
+        }
+    }
+    /**
+     * @returns next id from the batch,
+     *          undefined if ids are exhausted or not valid anymore
+     */
+    Batch.prototype.nextId = function () {
+        if (this.invalidSince <= Date.now()) {
+            return undefined;
+        }
+        if (this.firstInvalidId.equals(this.nextIdLong)) {
+            return undefined;
+        }
+        var returnLong = this.nextIdLong;
+        this.nextIdLong = this.nextIdLong.add(this.increment);
+        return returnLong;
+    };
+    return Batch;
+}());
+exports.Batch = Batch;
+var AutoBatcher = /** @class */ (function () {
+    function AutoBatcher(supplier) {
+        this.NEW_BATCH_AVAILABLE = 'newBatch';
+        this.queue = [];
+        this.requestInFlight = false;
+        this.emitter = new events_1.EventEmitter();
+        this.supplier = supplier;
+        this.emitter.on(this.NEW_BATCH_AVAILABLE, this.processIdRequests.bind(this));
+        this.emitter.on('error', this.rejectAll.bind(this));
+    }
+    AutoBatcher.prototype.processIdRequests = function () {
+        var ind = 0;
+        while (ind < this.queue.length) {
+            var nextId = void 0;
+            if (this.batch != null && (nextId = this.batch.nextId()) != null) {
+                this.queue[ind].resolve(nextId);
+                ind++;
+            }
+            else {
+                this.assignNewBatch();
+                break;
+            }
+        }
+        this.queue.splice(0, ind);
+    };
+    AutoBatcher.prototype.nextId = function () {
+        var deferred = Util_1.DeferredPromise();
+        this.queue.push(deferred);
+        this.processIdRequests();
+        return deferred.promise;
+    };
+    AutoBatcher.prototype.assignNewBatch = function () {
+        var _this = this;
+        if (this.requestInFlight) {
+            return;
+        }
+        this.requestInFlight = true;
+        this.supplier().then(function (batch) {
+            _this.requestInFlight = false;
+            _this.batch = batch;
+            _this.emitter.emit(_this.NEW_BATCH_AVAILABLE);
+        }).catch(function (e) {
+            _this.requestInFlight = false;
+            _this.emitter.emit('error', e);
+        });
+    };
+    AutoBatcher.prototype.rejectAll = function (e) {
+        this.queue.forEach(function (deferred) {
+            deferred.reject(e);
+        });
+        this.queue = [];
+    };
+    return AutoBatcher;
+}());
+exports.AutoBatcher = AutoBatcher;

package/lib/proxy/ringbuffer/LazyReadResultSet.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="long" />
+import * as Long from 'long';
+import { Data } from '../../serialization/Data';
+import { SerializationService } from '../../serialization/SerializationService';
+import { ReadResultSet } from './ReadResultSet';
+export declare class LazyReadResultSet<T> implements ReadResultSet<T> {
+    private readCount;
+    private items;
+    private itemSeqs;
+    private serializationService;
+    constructor(serializationService: SerializationService, readCount: number, items: Data[], itemSeqs: Long[]);
+    getReadCount(): number;
+    get(index: number): T;
+    getSequence(index: number): Long;
+    size(): number;
+}

package/lib/proxy/ringbuffer/LazyReadResultSet.js

@@ -0,0 +1,54 @@
+"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 });
+var HazelcastError_1 = require("../../HazelcastError");
+var LazyReadResultSet = /** @class */ (function () {
+    function LazyReadResultSet(serializationService, readCount, items, itemSeqs) {
+        this.serializationService = serializationService;
+        this.readCount = readCount;
+        this.items = items;
+        this.itemSeqs = itemSeqs;
+    }
+    LazyReadResultSet.prototype.getReadCount = function () {
+        return this.readCount;
+    };
+    LazyReadResultSet.prototype.get = function (index) {
+        var dataOrObject = this.items[index];
+        if (dataOrObject == null) {
+            return undefined;
+        }
+        if (this.serializationService.isData(dataOrObject)) {
+            var obj = this.serializationService.toObject(dataOrObject);
+            this.items[index] = obj;
+            return obj;
+        }
+        else {
+            return dataOrObject;
+        }
+    };
+    LazyReadResultSet.prototype.getSequence = function (index) {
+        if (this.itemSeqs == null) {
+            throw new HazelcastError_1.UnsupportedOperationError('Sequence IDs are not available when the cluster version is lower than 3.9');
+        }
+        return this.itemSeqs[index];
+    };
+    LazyReadResultSet.prototype.size = function () {
+        return this.items.length;
+    };
+    return LazyReadResultSet;
+}());
+exports.LazyReadResultSet = LazyReadResultSet;

package/lib/proxy/ringbuffer/ReadResultSet.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="long" />
+/**
+ * ReadResultSet defines the result of a {@lin RingBuffer#readMany} operation.
+ */
+import * as Long from 'long';
+export interface ReadResultSet<T> {
+    /**
+     * Returns the number of items that have been read before filtering.
+     * <p>
+     * If no filter is set, then the readCount will be equal to {@link #size}. But if a filter is applied, it could be that items
+     * are read, but are filtered out. So if you are trying to make another read based on the ReadResultSet then you should
+     * increment the sequence by readCount and not by size. Otherwise you will be re-reading the same filtered messages.
+     *
+     * @return the number of items read (including the filtered ones).
+     */
+    getReadCount(): number;
+    /**
+     * Gets the item at the given index.
+     *
+     * @param index
+     * @returns the found item or undefined if the index is out of bounds
+     */
+    get(index: number): T;
+    /**
+     * Return the sequence number for the item at the given index.
+     * The method throws if there are no sequences available.
+     * This can happen when the cluster version is lower than 3.9.
+     *
+     * @param index
+     * @throws UnsupportedOperationError if server version is 3.8 or lower.
+     * @requires Hazelcast 3.9
+     * @returns the sequence number for the ringbuffer item
+     *          undefined if the index is out of bounds.
+     */
+    getSequence(index: number): Long;
+    /**
+     * Returns the result set size.
+     * @returns the result set size
+     */
+    size(): number;
+}

package/lib/proxy/ringbuffer/ReadResultSet.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/ringbuffer/RingbufferProxy.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import { OverflowPolicy } from '../../core/OverflowPolicy';
+import { Ringbuffer } from '../Ringbuffer';
+import { PartitionSpecificProxy } from '../PartitionSpecificProxy';
+import { ReadResultSet } from './ReadResultSet';
+import Long = require('long');
+export declare class RingbufferProxy<E> extends PartitionSpecificProxy implements Ringbuffer<E> {
+    capacity(): Promise<Long>;
+    size(): Promise<Long>;
+    tailSequence(): Promise<Long>;
+    headSequence(): Promise<Long>;
+    remainingCapacity(): Promise<Long>;
+    add(item: E, overflowPolicy?: OverflowPolicy): Promise<Long>;
+    addAll(items: E[], overflowPolicy?: OverflowPolicy): Promise<Long>;
+    readOne(sequence: number | Long): Promise<E>;
+    readMany(sequence: number | Long, minCount: number, maxCount: number, filter?: any): Promise<ReadResultSet<E>>;
+}

package/lib/proxy/ringbuffer/RingbufferProxy.js

@@ -0,0 +1,98 @@
+"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 RingbufferAddAllCodec_1 = require("../../codec/RingbufferAddAllCodec");
+var RingbufferAddCodec_1 = require("../../codec/RingbufferAddCodec");
+var RingbufferCapacityCodec_1 = require("../../codec/RingbufferCapacityCodec");
+var RingbufferHeadSequenceCodec_1 = require("../../codec/RingbufferHeadSequenceCodec");
+var RingbufferReadManyCodec_1 = require("../../codec/RingbufferReadManyCodec");
+var RingbufferReadOneCodec_1 = require("../../codec/RingbufferReadOneCodec");
+var RingbufferRemainingCapacityCodec_1 = require("../../codec/RingbufferRemainingCapacityCodec");
+var RingbufferSizeCodec_1 = require("../../codec/RingbufferSizeCodec");
+var RingbufferTailSequenceCodec_1 = require("../../codec/RingbufferTailSequenceCodec");
+var OverflowPolicy_1 = require("../../core/OverflowPolicy");
+var PartitionSpecificProxy_1 = require("../PartitionSpecificProxy");
+var LazyReadResultSet_1 = require("./LazyReadResultSet");
+var Long = require("long");
+var RingbufferProxy = /** @class */ (function (_super) {
+    __extends(RingbufferProxy, _super);
+    function RingbufferProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RingbufferProxy.prototype.capacity = function () {
+        return this.encodeInvoke(RingbufferCapacityCodec_1.RingbufferCapacityCodec);
+    };
+    RingbufferProxy.prototype.size = function () {
+        return this.encodeInvoke(RingbufferSizeCodec_1.RingbufferSizeCodec);
+    };
+    RingbufferProxy.prototype.tailSequence = function () {
+        return this.encodeInvoke(RingbufferTailSequenceCodec_1.RingbufferTailSequenceCodec);
+    };
+    RingbufferProxy.prototype.headSequence = function () {
+        return this.encodeInvoke(RingbufferHeadSequenceCodec_1.RingbufferHeadSequenceCodec);
+    };
+    RingbufferProxy.prototype.remainingCapacity = function () {
+        return this.encodeInvoke(RingbufferRemainingCapacityCodec_1.RingbufferRemainingCapacityCodec);
+    };
+    RingbufferProxy.prototype.add = function (item, overflowPolicy) {
+        if (overflowPolicy === void 0) { overflowPolicy = OverflowPolicy_1.OverflowPolicy.OVERWRITE; }
+        return this.encodeInvoke(RingbufferAddCodec_1.RingbufferAddCodec, overflowPolicy, this.toData(item));
+    };
+    RingbufferProxy.prototype.addAll = function (items, overflowPolicy) {
+        var _this = this;
+        if (overflowPolicy === void 0) { overflowPolicy = OverflowPolicy_1.OverflowPolicy.OVERWRITE; }
+        var dataList = items.map(function (item) {
+            return _this.toData(item);
+        });
+        return this.encodeInvoke(RingbufferAddAllCodec_1.RingbufferAddAllCodec, dataList, overflowPolicy);
+    };
+    RingbufferProxy.prototype.readOne = function (sequence) {
+        if (Long.fromValue(sequence).lessThan(0)) {
+            throw new RangeError('Sequence number should not be less than zero, was: ' + sequence);
+        }
+        return this.encodeInvoke(RingbufferReadOneCodec_1.RingbufferReadOneCodec, sequence);
+    };
+    RingbufferProxy.prototype.readMany = function (sequence, minCount, maxCount, filter) {
+        var _this = this;
+        if (filter === void 0) { filter = null; }
+        if (Long.fromValue(sequence).lessThan(0)) {
+            throw new RangeError('Sequence number should not be less than zero, was: ' + sequence);
+        }
+        if (minCount < 0) {
+            throw new RangeError('Min count should not be less than zero, was: ' + sequence);
+        }
+        if (minCount > maxCount) {
+            throw new RangeError('Min count ' + minCount + 'was larger than max count ' + maxCount);
+        }
+        return this.encodeInvoke(RingbufferReadManyCodec_1.RingbufferReadManyCodec, sequence, minCount, maxCount, this.toData(filter))
+            .then(function (raw) {
+            return new LazyReadResultSet_1.LazyReadResultSet(_this.client.getSerializationService(), raw.readCount, raw.items, raw.itemSeqs);
+        });
+    };
+    return RingbufferProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.RingbufferProxy = RingbufferProxy;

package/lib/proxy/topic/ITopic.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { DistributedObject } from '../../DistributedObject';
+import { MessageListener } from './MessageListener';
+export interface ITopic<E> extends DistributedObject {
+    addMessageListener(listener: MessageListener<E>): string;
+    removeMessageListener(id: string): boolean;
+    publish(message: E): Promise<void>;
+}

package/lib/proxy/topic/ITopic.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/topic/Message.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="long" />
+import Long = require('long');
+import Address = require('../../Address');
+export declare class Message<T> {
+    messageObject: T;
+    publisher: Address;
+    publishingTime: Long;
+}