@celerispay/hazelcast-client 3.12.5

package/lib/codec/QueueDrainToMaxSizeCodec.js

@@ -0,0 +1,63 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_DRAINTOMAXSIZE;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = false;
+var QueueDrainToMaxSizeCodec = /** @class */ (function () {
+    function QueueDrainToMaxSizeCodec() {
+    }
+    QueueDrainToMaxSizeCodec.calculateSize = function (name, maxSize) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    QueueDrainToMaxSizeCodec.encodeRequest = function (name, maxSize) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, maxSize));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(maxSize);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueDrainToMaxSizeCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        var responseSize = clientMessage.readInt32();
+        var response = [];
+        for (var responseIndex = 0; responseIndex < responseSize; responseIndex++) {
+            var responseItem;
+            responseItem = clientMessage.readData();
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return QueueDrainToMaxSizeCodec;
+}());
+exports.QueueDrainToMaxSizeCodec = QueueDrainToMaxSizeCodec;

package/lib/codec/QueueIsEmptyCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueIsEmptyCodec {
+    static calculateSize(name: string): number;
+    static encodeRequest(name: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueueIsEmptyCodec.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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_ISEMPTY;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueIsEmptyCodec = /** @class */ (function () {
+    function QueueIsEmptyCodec() {
+    }
+    QueueIsEmptyCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueueIsEmptyCodec.encodeRequest = function (name) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueIsEmptyCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readBoolean();
+        return parameters;
+    };
+    return QueueIsEmptyCodec;
+}());
+exports.QueueIsEmptyCodec = QueueIsEmptyCodec;

package/lib/codec/QueueIteratorCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueIteratorCodec {
+    static calculateSize(name: string): number;
+    static encodeRequest(name: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueueIteratorCodec.js

@@ -0,0 +1,61 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_ITERATOR;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = false;
+var QueueIteratorCodec = /** @class */ (function () {
+    function QueueIteratorCodec() {
+    }
+    QueueIteratorCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueueIteratorCodec.encodeRequest = function (name) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueIteratorCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        var responseSize = clientMessage.readInt32();
+        var response = [];
+        for (var responseIndex = 0; responseIndex < responseSize; responseIndex++) {
+            var responseItem;
+            responseItem = clientMessage.readData();
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return QueueIteratorCodec;
+}());
+exports.QueueIteratorCodec = QueueIteratorCodec;

package/lib/codec/QueueMessageType.d.ts

@@ -0,0 +1,22 @@
+export declare class QueueMessageType {
+    static QUEUE_OFFER: number;
+    static QUEUE_PUT: number;
+    static QUEUE_SIZE: number;
+    static QUEUE_REMOVE: number;
+    static QUEUE_POLL: number;
+    static QUEUE_TAKE: number;
+    static QUEUE_PEEK: number;
+    static QUEUE_ITERATOR: number;
+    static QUEUE_DRAINTO: number;
+    static QUEUE_DRAINTOMAXSIZE: number;
+    static QUEUE_CONTAINS: number;
+    static QUEUE_CONTAINSALL: number;
+    static QUEUE_COMPAREANDREMOVEALL: number;
+    static QUEUE_COMPAREANDRETAINALL: number;
+    static QUEUE_CLEAR: number;
+    static QUEUE_ADDALL: number;
+    static QUEUE_ADDLISTENER: number;
+    static QUEUE_REMOVELISTENER: number;
+    static QUEUE_REMAININGCAPACITY: number;
+    static QUEUE_ISEMPTY: number;
+}

package/lib/codec/QueueMessageType.js

@@ -0,0 +1,44 @@
+"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 });
+/* tslint:disable */
+var QueueMessageType = /** @class */ (function () {
+    function QueueMessageType() {
+    }
+    QueueMessageType.QUEUE_OFFER = 0x0301;
+    QueueMessageType.QUEUE_PUT = 0x0302;
+    QueueMessageType.QUEUE_SIZE = 0x0303;
+    QueueMessageType.QUEUE_REMOVE = 0x0304;
+    QueueMessageType.QUEUE_POLL = 0x0305;
+    QueueMessageType.QUEUE_TAKE = 0x0306;
+    QueueMessageType.QUEUE_PEEK = 0x0307;
+    QueueMessageType.QUEUE_ITERATOR = 0x0308;
+    QueueMessageType.QUEUE_DRAINTO = 0x0309;
+    QueueMessageType.QUEUE_DRAINTOMAXSIZE = 0x030a;
+    QueueMessageType.QUEUE_CONTAINS = 0x030b;
+    QueueMessageType.QUEUE_CONTAINSALL = 0x030c;
+    QueueMessageType.QUEUE_COMPAREANDREMOVEALL = 0x030d;
+    QueueMessageType.QUEUE_COMPAREANDRETAINALL = 0x030e;
+    QueueMessageType.QUEUE_CLEAR = 0x030f;
+    QueueMessageType.QUEUE_ADDALL = 0x0310;
+    QueueMessageType.QUEUE_ADDLISTENER = 0x0311;
+    QueueMessageType.QUEUE_REMOVELISTENER = 0x0312;
+    QueueMessageType.QUEUE_REMAININGCAPACITY = 0x0313;
+    QueueMessageType.QUEUE_ISEMPTY = 0x0314;
+    return QueueMessageType;
+}());
+exports.QueueMessageType = QueueMessageType;

package/lib/codec/QueueOfferCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueOfferCodec {
+    static calculateSize(name: string, value: Data, timeoutMillis: any): number;
+    static encodeRequest(name: string, value: Data, timeoutMillis: any): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueueOfferCodec.js

@@ -0,0 +1,58 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_OFFER;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueOfferCodec = /** @class */ (function () {
+    function QueueOfferCodec() {
+    }
+    QueueOfferCodec.calculateSize = function (name, value, timeoutMillis) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(value);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    QueueOfferCodec.encodeRequest = function (name, value, timeoutMillis) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, value, timeoutMillis));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(timeoutMillis);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueOfferCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readBoolean();
+        return parameters;
+    };
+    return QueueOfferCodec;
+}());
+exports.QueueOfferCodec = QueueOfferCodec;

package/lib/codec/QueuePeekCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueuePeekCodec {
+    static calculateSize(name: string): number;
+    static encodeRequest(name: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueuePeekCodec.js

@@ -0,0 +1,56 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_PEEK;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var QueuePeekCodec = /** @class */ (function () {
+    function QueuePeekCodec() {
+    }
+    QueuePeekCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueuePeekCodec.encodeRequest = function (name) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueuePeekCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        if (clientMessage.readBoolean() !== true) {
+            parameters['response'] = toObjectFunction(clientMessage.readData());
+        }
+        return parameters;
+    };
+    return QueuePeekCodec;
+}());
+exports.QueuePeekCodec = QueuePeekCodec;

package/lib/codec/QueuePollCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueuePollCodec {
+    static calculateSize(name: string, timeoutMillis: any): number;
+    static encodeRequest(name: string, timeoutMillis: any): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueuePollCodec.js

@@ -0,0 +1,58 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_POLL;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var QueuePollCodec = /** @class */ (function () {
+    function QueuePollCodec() {
+    }
+    QueuePollCodec.calculateSize = function (name, timeoutMillis) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    QueuePollCodec.encodeRequest = function (name, timeoutMillis) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, timeoutMillis));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendLong(timeoutMillis);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueuePollCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        if (clientMessage.readBoolean() !== true) {
+            parameters['response'] = toObjectFunction(clientMessage.readData());
+        }
+        return parameters;
+    };
+    return QueuePollCodec;
+}());
+exports.QueuePollCodec = QueuePollCodec;

package/lib/codec/QueuePutCodec.d.ts

@@ -0,0 +1,6 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueuePutCodec {
+    static calculateSize(name: string, value: Data): number;
+    static encodeRequest(name: string, value: Data): ClientMessage;
+}

package/lib/codec/QueuePutCodec.js

@@ -0,0 +1,47 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_PUT;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var QueuePutCodec = /** @class */ (function () {
+    function QueuePutCodec() {
+    }
+    QueuePutCodec.calculateSize = function (name, value) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(value);
+        return dataSize;
+    };
+    QueuePutCodec.encodeRequest = function (name, value) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, value));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(value);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return QueuePutCodec;
+}());
+exports.QueuePutCodec = QueuePutCodec;

package/lib/codec/QueueRemainingCapacityCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueRemainingCapacityCodec {
+    static calculateSize(name: string): number;
+    static encodeRequest(name: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueueRemainingCapacityCodec.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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_REMAININGCAPACITY;
+var RESPONSE_TYPE = 102;
+var RETRYABLE = false;
+var QueueRemainingCapacityCodec = /** @class */ (function () {
+    function QueueRemainingCapacityCodec() {
+    }
+    QueueRemainingCapacityCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueueRemainingCapacityCodec.encodeRequest = function (name) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueRemainingCapacityCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readInt32();
+        return parameters;
+    };
+    return QueueRemainingCapacityCodec;
+}());
+exports.QueueRemainingCapacityCodec = QueueRemainingCapacityCodec;

package/lib/codec/QueueRemoveCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueRemoveCodec {
+    static calculateSize(name: string, value: Data): number;
+    static encodeRequest(name: string, value: Data): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/QueueRemoveCodec.js

@@ -0,0 +1,56 @@
+"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 });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_REMOVE;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueRemoveCodec = /** @class */ (function () {
+    function QueueRemoveCodec() {
+    }
+    QueueRemoveCodec.calculateSize = function (name, value) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(value);
+        return dataSize;
+    };
+    QueueRemoveCodec.encodeRequest = function (name, value) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, value));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(value);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueRemoveCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readBoolean();
+        return parameters;
+    };
+    return QueueRemoveCodec;
+}());
+exports.QueueRemoveCodec = QueueRemoveCodec;

package/lib/codec/QueueRemoveListenerCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueRemoveListenerCodec {
+    static calculateSize(name: string, registrationId: string): number;
+    static encodeRequest(name: string, registrationId: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}