@celerispay/hazelcast-client 3.12.5

package/lib/proxy/PartitionSpecificProxy.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import HazelcastClient from '../HazelcastClient';
+import { BaseProxy } from './BaseProxy';
+export declare class PartitionSpecificProxy extends BaseProxy {
+    private partitionId;
+    constructor(client: HazelcastClient, serviceName: string, name: string);
+    protected encodeInvoke<T>(codec: any, ...codecArguments: any[]): Promise<T>;
+    protected encodeInvokeWithTimeout<T>(timeoutMillis: number, codec: any, ...codecArguments: any[]): Promise<T>;
+}

package/lib/proxy/PartitionSpecificProxy.js

@@ -0,0 +1,52 @@
+"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 BaseProxy_1 = require("./BaseProxy");
+var PartitionSpecificProxy = /** @class */ (function (_super) {
+    __extends(PartitionSpecificProxy, _super);
+    function PartitionSpecificProxy(client, serviceName, name) {
+        var _this = _super.call(this, client, serviceName, name) || this;
+        _this.partitionId = _this.client.getPartitionService().getPartitionId(_this.getPartitionKey());
+        return _this;
+    }
+    PartitionSpecificProxy.prototype.encodeInvoke = function (codec) {
+        var codecArguments = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            codecArguments[_i - 1] = arguments[_i];
+        }
+        return this.encodeInvokeOnPartition.apply(this, [codec, this.partitionId].concat(codecArguments));
+    };
+    PartitionSpecificProxy.prototype.encodeInvokeWithTimeout = function (timeoutMillis, codec) {
+        var codecArguments = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            codecArguments[_i - 2] = arguments[_i];
+        }
+        return this.encodeInvokeOnPartitionWithTimeout.apply(this, [timeoutMillis, codec, this.partitionId].concat(codecArguments));
+    };
+    return PartitionSpecificProxy;
+}(BaseProxy_1.BaseProxy));
+exports.PartitionSpecificProxy = PartitionSpecificProxy;

package/lib/proxy/ProxyManager.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { DistributedObject } from '../DistributedObject';
+import HazelcastClient from '../HazelcastClient';
+import { HazelcastError } from '../HazelcastError';
+import { DistributedObjectListener } from '../core/DistributedObjectListener';
+export declare class ProxyManager {
+    static readonly MAP_SERVICE: string;
+    static readonly SET_SERVICE: string;
+    static readonly LOCK_SERVICE: string;
+    static readonly QUEUE_SERVICE: string;
+    static readonly LIST_SERVICE: string;
+    static readonly MULTIMAP_SERVICE: string;
+    static readonly RINGBUFFER_SERVICE: string;
+    static readonly REPLICATEDMAP_SERVICE: string;
+    static readonly SEMAPHORE_SERVICE: string;
+    static readonly ATOMICLONG_SERVICE: string;
+    static readonly FLAKEID_SERVICE: string;
+    static readonly PNCOUNTER_SERVICE: string;
+    static readonly RELIABLETOPIC_SERVICE: string;
+    readonly service: {
+        [serviceName: string]: any;
+    };
+    private readonly proxies;
+    private readonly client;
+    private readonly logger;
+    private readonly invocationTimeoutMillis;
+    private readonly invocationRetryPauseMillis;
+    constructor(client: HazelcastClient);
+    init(): void;
+    getOrCreateProxy(name: string, serviceName: string, createAtServer?: boolean): Promise<DistributedObject>;
+    destroyProxy(name: string, serviceName: string): Promise<void>;
+    addDistributedObjectListener(distributedObjectListener: DistributedObjectListener): Promise<string>;
+    removeDistributedObjectListener(listenerId: string): Promise<boolean>;
+    protected isRetryable(error: HazelcastError): boolean;
+    private createProxy(proxyObject);
+    private findNextAddress();
+    private initializeProxy(proxyObject, promise, deadline);
+    private createDistributedObjectListener();
+}

package/lib/proxy/ProxyManager.js

@@ -0,0 +1,202 @@
+"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 ClientAddDistributedObjectListenerCodec_1 = require("../codec/ClientAddDistributedObjectListenerCodec");
+var ClientCreateProxyCodec_1 = require("../codec/ClientCreateProxyCodec");
+var ClientDestroyProxyCodec_1 = require("../codec/ClientDestroyProxyCodec");
+var ClientRemoveDistributedObjectListenerCodec_1 = require("../codec/ClientRemoveDistributedObjectListenerCodec");
+var HazelcastError_1 = require("../HazelcastError");
+var InvocationService_1 = require("../invocation/InvocationService");
+var AtomicLongProxy_1 = require("./AtomicLongProxy");
+var FlakeIdGeneratorProxy_1 = require("./FlakeIdGeneratorProxy");
+var ListProxy_1 = require("./ListProxy");
+var LockProxy_1 = require("./LockProxy");
+var MapProxy_1 = require("./MapProxy");
+var MultiMapProxy_1 = require("./MultiMapProxy");
+var NearCachedMapProxy_1 = require("./NearCachedMapProxy");
+var PNCounterProxy_1 = require("./PNCounterProxy");
+var QueueProxy_1 = require("./QueueProxy");
+var ReplicatedMapProxy_1 = require("./ReplicatedMapProxy");
+var RingbufferProxy_1 = require("./ringbuffer/RingbufferProxy");
+var SemaphoreProxy_1 = require("./SemaphoreProxy");
+var SetProxy_1 = require("./SetProxy");
+var ReliableTopicProxy_1 = require("./topic/ReliableTopicProxy");
+var DistributedObjectListener_1 = require("../core/DistributedObjectListener");
+var Util_1 = require("../Util");
+var ProxyManager = /** @class */ (function () {
+    function ProxyManager(client) {
+        this.service = {};
+        this.proxies = {};
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        this.invocationTimeoutMillis = this.client.getInvocationService().getInvocationTimeoutMillis();
+        this.invocationRetryPauseMillis = this.client.getInvocationService().getInvocationRetryPauseMillis();
+    }
+    ProxyManager.prototype.init = function () {
+        this.service[ProxyManager.MAP_SERVICE] = MapProxy_1.MapProxy;
+        this.service[ProxyManager.SET_SERVICE] = SetProxy_1.SetProxy;
+        this.service[ProxyManager.QUEUE_SERVICE] = QueueProxy_1.QueueProxy;
+        this.service[ProxyManager.LIST_SERVICE] = ListProxy_1.ListProxy;
+        this.service[ProxyManager.LOCK_SERVICE] = LockProxy_1.LockProxy;
+        this.service[ProxyManager.MULTIMAP_SERVICE] = MultiMapProxy_1.MultiMapProxy;
+        this.service[ProxyManager.RINGBUFFER_SERVICE] = RingbufferProxy_1.RingbufferProxy;
+        this.service[ProxyManager.REPLICATEDMAP_SERVICE] = ReplicatedMapProxy_1.ReplicatedMapProxy;
+        this.service[ProxyManager.SEMAPHORE_SERVICE] = SemaphoreProxy_1.SemaphoreProxy;
+        this.service[ProxyManager.ATOMICLONG_SERVICE] = AtomicLongProxy_1.AtomicLongProxy;
+        this.service[ProxyManager.FLAKEID_SERVICE] = FlakeIdGeneratorProxy_1.FlakeIdGeneratorProxy;
+        this.service[ProxyManager.PNCOUNTER_SERVICE] = PNCounterProxy_1.PNCounterProxy;
+        this.service[ProxyManager.RELIABLETOPIC_SERVICE] = ReliableTopicProxy_1.ReliableTopicProxy;
+    };
+    ProxyManager.prototype.getOrCreateProxy = function (name, serviceName, createAtServer) {
+        var _this = this;
+        if (createAtServer === void 0) { createAtServer = true; }
+        var fullName = serviceName + name;
+        if (this.proxies[fullName]) {
+            return this.proxies[fullName];
+        }
+        var deferred = Util_1.DeferredPromise();
+        var newProxy;
+        if (serviceName === ProxyManager.MAP_SERVICE && this.client.getConfig().getNearCacheConfig(name)) {
+            newProxy = new NearCachedMapProxy_1.NearCachedMapProxy(this.client, serviceName, name);
+        }
+        else if (serviceName === ProxyManager.RELIABLETOPIC_SERVICE) {
+            newProxy = new ReliableTopicProxy_1.ReliableTopicProxy(this.client, serviceName, name);
+            if (createAtServer) {
+                newProxy.setRingbuffer().then(function () {
+                    return _this.createProxy(newProxy);
+                }).then(function () {
+                    deferred.resolve(newProxy);
+                });
+            }
+            this.proxies[fullName] = deferred.promise;
+            return deferred.promise;
+        }
+        else {
+            newProxy = new this.service[serviceName](this.client, serviceName, name);
+        }
+        if (createAtServer) {
+            this.createProxy(newProxy).then(function () {
+                deferred.resolve(newProxy);
+            });
+        }
+        this.proxies[fullName] = deferred.promise;
+        return deferred.promise;
+    };
+    ProxyManager.prototype.destroyProxy = function (name, serviceName) {
+        delete this.proxies[serviceName + name];
+        var clientMessage = ClientDestroyProxyCodec_1.ClientDestroyProxyCodec.encodeRequest(name, serviceName);
+        clientMessage.setPartitionId(-1);
+        return this.client.getInvocationService().invokeOnRandomTarget(clientMessage).return();
+    };
+    ProxyManager.prototype.addDistributedObjectListener = function (distributedObjectListener) {
+        var handler = function (clientMessage) {
+            var converterFunc = function (objectName, serviceName, eventType) {
+                eventType = eventType.toLowerCase();
+                var distributedObjectEvent = new DistributedObjectListener_1.DistributedObjectEvent(eventType, serviceName, objectName);
+                distributedObjectListener(distributedObjectEvent);
+            };
+            ClientAddDistributedObjectListenerCodec_1.ClientAddDistributedObjectListenerCodec.handle(clientMessage, converterFunc, null);
+        };
+        var codec = this.createDistributedObjectListener();
+        return this.client.getListenerService().registerListener(codec, handler);
+    };
+    ProxyManager.prototype.removeDistributedObjectListener = function (listenerId) {
+        return this.client.getListenerService().deregisterListener(listenerId);
+    };
+    ProxyManager.prototype.isRetryable = function (error) {
+        if (error instanceof HazelcastError_1.ClientNotActiveError) {
+            return false;
+        }
+        return true;
+    };
+    ProxyManager.prototype.createProxy = function (proxyObject) {
+        var promise = Util_1.DeferredPromise();
+        this.initializeProxy(proxyObject, promise, Date.now() + this.invocationTimeoutMillis);
+        return promise.promise;
+    };
+    ProxyManager.prototype.findNextAddress = function () {
+        var members = this.client.getClusterService().getMembers();
+        var liteMember = null;
+        for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+            var member = members_1[_i];
+            if (member != null && member.isLiteMember === false) {
+                return member.address;
+            }
+            else if (member != null && member.isLiteMember) {
+                liteMember = member;
+            }
+        }
+        if (liteMember != null) {
+            return liteMember.address;
+        }
+        else {
+            return null;
+        }
+    };
+    ProxyManager.prototype.initializeProxy = function (proxyObject, promise, deadline) {
+        var _this = this;
+        if (Date.now() <= deadline) {
+            var address = this.findNextAddress();
+            var request = ClientCreateProxyCodec_1.ClientCreateProxyCodec.encodeRequest(proxyObject.getName(), proxyObject.getServiceName(), address);
+            var invocation = new InvocationService_1.Invocation(this.client, request);
+            invocation.address = address;
+            this.client.getInvocationService().invoke(invocation).then(function (response) {
+                promise.resolve(response);
+            }).catch(function (error) {
+                if (_this.isRetryable(error)) {
+                    _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() +
+                        ' failed. Retrying in ' + _this.invocationRetryPauseMillis + 'ms. ' + error);
+                    setTimeout(_this.initializeProxy.bind(_this, proxyObject, promise, deadline), _this.invocationRetryPauseMillis);
+                }
+                else {
+                    _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
+                }
+            });
+        }
+        else {
+            promise.reject('Create proxy request timed-out for ' + proxyObject.getName());
+        }
+    };
+    ProxyManager.prototype.createDistributedObjectListener = function () {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return ClientAddDistributedObjectListenerCodec_1.ClientAddDistributedObjectListenerCodec.encodeRequest(localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return ClientAddDistributedObjectListenerCodec_1.ClientAddDistributedObjectListenerCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return ClientRemoveDistributedObjectListenerCodec_1.ClientRemoveDistributedObjectListenerCodec.encodeRequest(listenerId);
+            },
+        };
+    };
+    ProxyManager.MAP_SERVICE = 'hz:impl:mapService';
+    ProxyManager.SET_SERVICE = 'hz:impl:setService';
+    ProxyManager.LOCK_SERVICE = 'hz:impl:lockService';
+    ProxyManager.QUEUE_SERVICE = 'hz:impl:queueService';
+    ProxyManager.LIST_SERVICE = 'hz:impl:listService';
+    ProxyManager.MULTIMAP_SERVICE = 'hz:impl:multiMapService';
+    ProxyManager.RINGBUFFER_SERVICE = 'hz:impl:ringbufferService';
+    ProxyManager.REPLICATEDMAP_SERVICE = 'hz:impl:replicatedMapService';
+    ProxyManager.SEMAPHORE_SERVICE = 'hz:impl:semaphoreService';
+    ProxyManager.ATOMICLONG_SERVICE = 'hz:impl:atomicLongService';
+    ProxyManager.FLAKEID_SERVICE = 'hz:impl:flakeIdGeneratorService';
+    ProxyManager.PNCOUNTER_SERVICE = 'hz:impl:PNCounterService';
+    ProxyManager.RELIABLETOPIC_SERVICE = 'hz:impl:reliableTopicService';
+    return ProxyManager;
+}());
+exports.ProxyManager = ProxyManager;

package/lib/proxy/QueueProxy.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ItemListener } from '../core/ItemListener';
+import { IQueue } from './IQueue';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+export declare class QueueProxy<E> extends PartitionSpecificProxy implements IQueue<E> {
+    add(item: E): Promise<boolean>;
+    addAll(items: E[]): Promise<boolean>;
+    addItemListener(listener: ItemListener<E>, includeValue: boolean): Promise<string>;
+    clear(): Promise<void>;
+    contains(item: E): Promise<boolean>;
+    containsAll(items: E[]): Promise<boolean>;
+    drainTo(arr: E[], maxElements?: number): Promise<number>;
+    isEmpty(): Promise<boolean>;
+    offer(item: E, time?: number): Promise<boolean>;
+    peek(): Promise<E>;
+    poll(time?: number): Promise<E>;
+    put(item: E): Promise<void>;
+    remainingCapacity(): Promise<number>;
+    remove(item: E): Promise<boolean>;
+    removeAll(items: E[]): Promise<boolean>;
+    removeItemListener(registrationId: string): Promise<boolean>;
+    retainAll(items: E[]): Promise<boolean>;
+    size(): Promise<number>;
+    take(): Promise<E>;
+    toArray(): Promise<E[]>;
+    private createEntryListener(name, includeValue);
+}

package/lib/proxy/QueueProxy.js

@@ -0,0 +1,198 @@
+"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 QueueAddAllCodec_1 = require("../codec/QueueAddAllCodec");
+var QueueAddListenerCodec_1 = require("../codec/QueueAddListenerCodec");
+var QueueClearCodec_1 = require("../codec/QueueClearCodec");
+var QueueCompareAndRemoveAllCodec_1 = require("../codec/QueueCompareAndRemoveAllCodec");
+var QueueCompareAndRetainAllCodec_1 = require("../codec/QueueCompareAndRetainAllCodec");
+var QueueContainsAllCodec_1 = require("../codec/QueueContainsAllCodec");
+var QueueContainsCodec_1 = require("../codec/QueueContainsCodec");
+var QueueDrainToCodec_1 = require("../codec/QueueDrainToCodec");
+var QueueDrainToMaxSizeCodec_1 = require("../codec/QueueDrainToMaxSizeCodec");
+var QueueIsEmptyCodec_1 = require("../codec/QueueIsEmptyCodec");
+var QueueIteratorCodec_1 = require("../codec/QueueIteratorCodec");
+var QueueOfferCodec_1 = require("../codec/QueueOfferCodec");
+var QueuePeekCodec_1 = require("../codec/QueuePeekCodec");
+var QueuePollCodec_1 = require("../codec/QueuePollCodec");
+var QueuePutCodec_1 = require("../codec/QueuePutCodec");
+var QueueRemainingCapacityCodec_1 = require("../codec/QueueRemainingCapacityCodec");
+var QueueRemoveCodec_1 = require("../codec/QueueRemoveCodec");
+var QueueRemoveListenerCodec_1 = require("../codec/QueueRemoveListenerCodec");
+var QueueSizeCodec_1 = require("../codec/QueueSizeCodec");
+var QueueTakeCodec_1 = require("../codec/QueueTakeCodec");
+var ItemListener_1 = require("../core/ItemListener");
+var HazelcastError_1 = require("../HazelcastError");
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var QueueProxy = /** @class */ (function (_super) {
+    __extends(QueueProxy, _super);
+    function QueueProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    QueueProxy.prototype.add = function (item) {
+        return this.offer(item).then(function (ret) {
+            if (ret) {
+                return true;
+            }
+            else {
+                throw new HazelcastError_1.IllegalStateError('Queue is full.');
+            }
+        });
+    };
+    QueueProxy.prototype.addAll = function (items) {
+        var rawList = [];
+        var toData = this.toData.bind(this);
+        items.forEach(function (item) {
+            rawList.push(toData(item));
+        });
+        return this.encodeInvoke(QueueAddAllCodec_1.QueueAddAllCodec, rawList);
+    };
+    QueueProxy.prototype.addItemListener = function (listener, includeValue) {
+        var _this = this;
+        var handler = function (message) {
+            QueueAddListenerCodec_1.QueueAddListenerCodec.handle(message, function (item, uuid, eventType) {
+                var responseObject;
+                if (item == null) {
+                    responseObject = null;
+                }
+                else {
+                    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);
+    };
+    QueueProxy.prototype.clear = function () {
+        return this.encodeInvoke(QueueClearCodec_1.QueueClearCodec);
+    };
+    QueueProxy.prototype.contains = function (item) {
+        var itemData = this.toData(item);
+        return this.encodeInvoke(QueueContainsCodec_1.QueueContainsCodec, itemData);
+    };
+    QueueProxy.prototype.containsAll = function (items) {
+        var toData = this.toData.bind(this);
+        var rawItems = items.map(toData);
+        return this.encodeInvoke(QueueContainsAllCodec_1.QueueContainsAllCodec, rawItems);
+    };
+    QueueProxy.prototype.drainTo = function (arr, maxElements) {
+        if (maxElements === void 0) { maxElements = null; }
+        var toObject = this.toObject.bind(this);
+        var promise;
+        if (maxElements === null) {
+            promise = this.encodeInvoke(QueueDrainToCodec_1.QueueDrainToCodec);
+        }
+        else {
+            promise = this.encodeInvoke(QueueDrainToMaxSizeCodec_1.QueueDrainToMaxSizeCodec, maxElements);
+        }
+        return promise.then(function (rawArr) {
+            rawArr.forEach(function (rawItem) {
+                arr.push(toObject(rawItem));
+            });
+            return rawArr.length;
+        });
+    };
+    QueueProxy.prototype.isEmpty = function () {
+        return this.encodeInvoke(QueueIsEmptyCodec_1.QueueIsEmptyCodec);
+    };
+    QueueProxy.prototype.offer = function (item, time) {
+        if (time === void 0) { time = 0; }
+        var itemData = this.toData(item);
+        return this.encodeInvoke(QueueOfferCodec_1.QueueOfferCodec, itemData, time);
+    };
+    QueueProxy.prototype.peek = function () {
+        return this.encodeInvoke(QueuePeekCodec_1.QueuePeekCodec);
+    };
+    QueueProxy.prototype.poll = function (time) {
+        if (time === void 0) { time = 0; }
+        return this.encodeInvoke(QueuePollCodec_1.QueuePollCodec, time);
+    };
+    QueueProxy.prototype.put = function (item) {
+        var itemData = this.toData(item);
+        return this.encodeInvoke(QueuePutCodec_1.QueuePutCodec, itemData);
+    };
+    QueueProxy.prototype.remainingCapacity = function () {
+        return this.encodeInvoke(QueueRemainingCapacityCodec_1.QueueRemainingCapacityCodec);
+    };
+    QueueProxy.prototype.remove = function (item) {
+        var itemData = this.toData(item);
+        return this.encodeInvoke(QueueRemoveCodec_1.QueueRemoveCodec, itemData);
+    };
+    QueueProxy.prototype.removeAll = function (items) {
+        var toData = this.toData.bind(this);
+        var rawItems = items.map(toData);
+        return this.encodeInvoke(QueueCompareAndRemoveAllCodec_1.QueueCompareAndRemoveAllCodec, rawItems);
+    };
+    QueueProxy.prototype.removeItemListener = function (registrationId) {
+        return this.client.getListenerService().deregisterListener(registrationId);
+    };
+    QueueProxy.prototype.retainAll = function (items) {
+        var toData = this.toData.bind(this);
+        var rawItems = items.map(toData);
+        return this.encodeInvoke(QueueCompareAndRetainAllCodec_1.QueueCompareAndRetainAllCodec, rawItems);
+    };
+    QueueProxy.prototype.size = function () {
+        return this.encodeInvoke(QueueSizeCodec_1.QueueSizeCodec);
+    };
+    QueueProxy.prototype.take = function () {
+        return this.encodeInvoke(QueueTakeCodec_1.QueueTakeCodec);
+    };
+    QueueProxy.prototype.toArray = function () {
+        var arr = [];
+        var toObject = this.toObject.bind(this);
+        return this.encodeInvoke(QueueIteratorCodec_1.QueueIteratorCodec).then(function (dataArray) {
+            dataArray.forEach(function (data) {
+                arr.push(toObject(data));
+            });
+            return arr;
+        });
+    };
+    QueueProxy.prototype.createEntryListener = function (name, includeValue) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return QueueAddListenerCodec_1.QueueAddListenerCodec.encodeRequest(name, includeValue, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return QueueAddListenerCodec_1.QueueAddListenerCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return QueueRemoveListenerCodec_1.QueueRemoveListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    return QueueProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.QueueProxy = QueueProxy;