@celerispay/hazelcast-client 3.12.5

package/lib/codec/MultiMapEntrySetCodec.js

@@ -0,0 +1,65 @@
+"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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_ENTRYSET;
+var RESPONSE_TYPE = 117;
+var RETRYABLE = true;
+var MultiMapEntrySetCodec = /** @class */ (function () {
+    function MultiMapEntrySetCodec() {
+    }
+    MultiMapEntrySetCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    MultiMapEntrySetCodec.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;
+    };
+    MultiMapEntrySetCodec.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;
+            var responseItemKey;
+            var responseItemVal;
+            responseItemKey = clientMessage.readData();
+            responseItemVal = clientMessage.readData();
+            responseItem = [responseItemKey, responseItemVal];
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return MultiMapEntrySetCodec;
+}());
+exports.MultiMapEntrySetCodec = MultiMapEntrySetCodec;

package/lib/codec/MultiMapForceUnlockCodec.d.ts

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

package/lib/codec/MultiMapForceUnlockCodec.js

@@ -0,0 +1,49 @@
+"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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_FORCEUNLOCK;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = true;
+var MultiMapForceUnlockCodec = /** @class */ (function () {
+    function MultiMapForceUnlockCodec() {
+    }
+    MultiMapForceUnlockCodec.calculateSize = function (name, key, referenceId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapForceUnlockCodec.encodeRequest = function (name, key, referenceId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, referenceId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(referenceId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MultiMapForceUnlockCodec;
+}());
+exports.MultiMapForceUnlockCodec = MultiMapForceUnlockCodec;

package/lib/codec/MultiMapGetCodec.d.ts

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

package/lib/codec/MultiMapGetCodec.js

@@ -0,0 +1,65 @@
+"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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_GET;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = true;
+var MultiMapGetCodec = /** @class */ (function () {
+    function MultiMapGetCodec() {
+    }
+    MultiMapGetCodec.calculateSize = function (name, key, threadId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapGetCodec.encodeRequest = function (name, key, threadId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, threadId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(threadId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapGetCodec.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 MultiMapGetCodec;
+}());
+exports.MultiMapGetCodec = MultiMapGetCodec;

package/lib/codec/MultiMapIsLockedCodec.d.ts

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

package/lib/codec/MultiMapIsLockedCodec.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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_ISLOCKED;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = true;
+var MultiMapIsLockedCodec = /** @class */ (function () {
+    function MultiMapIsLockedCodec() {
+    }
+    MultiMapIsLockedCodec.calculateSize = function (name, key) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        return dataSize;
+    };
+    MultiMapIsLockedCodec.encodeRequest = function (name, key) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapIsLockedCodec.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 MultiMapIsLockedCodec;
+}());
+exports.MultiMapIsLockedCodec = MultiMapIsLockedCodec;

package/lib/codec/MultiMapKeySetCodec.d.ts

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

package/lib/codec/MultiMapKeySetCodec.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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_KEYSET;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = true;
+var MultiMapKeySetCodec = /** @class */ (function () {
+    function MultiMapKeySetCodec() {
+    }
+    MultiMapKeySetCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    MultiMapKeySetCodec.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;
+    };
+    MultiMapKeySetCodec.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 MultiMapKeySetCodec;
+}());
+exports.MultiMapKeySetCodec = MultiMapKeySetCodec;

package/lib/codec/MultiMapLockCodec.d.ts

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

package/lib/codec/MultiMapLockCodec.js

@@ -0,0 +1,53 @@
+"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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_LOCK;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = true;
+var MultiMapLockCodec = /** @class */ (function () {
+    function MultiMapLockCodec() {
+    }
+    MultiMapLockCodec.calculateSize = function (name, key, threadId, ttl, referenceId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapLockCodec.encodeRequest = function (name, key, threadId, ttl, referenceId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, threadId, ttl, referenceId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(threadId);
+        clientMessage.appendLong(ttl);
+        clientMessage.appendLong(referenceId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MultiMapLockCodec;
+}());
+exports.MultiMapLockCodec = MultiMapLockCodec;

package/lib/codec/MultiMapMessageType.d.ts

@@ -0,0 +1,23 @@
+export declare class MultiMapMessageType {
+    static MULTIMAP_PUT: number;
+    static MULTIMAP_GET: number;
+    static MULTIMAP_REMOVE: number;
+    static MULTIMAP_KEYSET: number;
+    static MULTIMAP_VALUES: number;
+    static MULTIMAP_ENTRYSET: number;
+    static MULTIMAP_CONTAINSKEY: number;
+    static MULTIMAP_CONTAINSVALUE: number;
+    static MULTIMAP_CONTAINSENTRY: number;
+    static MULTIMAP_SIZE: number;
+    static MULTIMAP_CLEAR: number;
+    static MULTIMAP_VALUECOUNT: number;
+    static MULTIMAP_ADDENTRYLISTENERTOKEY: number;
+    static MULTIMAP_ADDENTRYLISTENER: number;
+    static MULTIMAP_REMOVEENTRYLISTENER: number;
+    static MULTIMAP_LOCK: number;
+    static MULTIMAP_TRYLOCK: number;
+    static MULTIMAP_ISLOCKED: number;
+    static MULTIMAP_UNLOCK: number;
+    static MULTIMAP_FORCEUNLOCK: number;
+    static MULTIMAP_REMOVEENTRY: number;
+}

package/lib/codec/MultiMapMessageType.js

@@ -0,0 +1,45 @@
+"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 MultiMapMessageType = /** @class */ (function () {
+    function MultiMapMessageType() {
+    }
+    MultiMapMessageType.MULTIMAP_PUT = 0x0201;
+    MultiMapMessageType.MULTIMAP_GET = 0x0202;
+    MultiMapMessageType.MULTIMAP_REMOVE = 0x0203;
+    MultiMapMessageType.MULTIMAP_KEYSET = 0x0204;
+    MultiMapMessageType.MULTIMAP_VALUES = 0x0205;
+    MultiMapMessageType.MULTIMAP_ENTRYSET = 0x0206;
+    MultiMapMessageType.MULTIMAP_CONTAINSKEY = 0x0207;
+    MultiMapMessageType.MULTIMAP_CONTAINSVALUE = 0x0208;
+    MultiMapMessageType.MULTIMAP_CONTAINSENTRY = 0x0209;
+    MultiMapMessageType.MULTIMAP_SIZE = 0x020a;
+    MultiMapMessageType.MULTIMAP_CLEAR = 0x020b;
+    MultiMapMessageType.MULTIMAP_VALUECOUNT = 0x020c;
+    MultiMapMessageType.MULTIMAP_ADDENTRYLISTENERTOKEY = 0x020d;
+    MultiMapMessageType.MULTIMAP_ADDENTRYLISTENER = 0x020e;
+    MultiMapMessageType.MULTIMAP_REMOVEENTRYLISTENER = 0x020f;
+    MultiMapMessageType.MULTIMAP_LOCK = 0x0210;
+    MultiMapMessageType.MULTIMAP_TRYLOCK = 0x0211;
+    MultiMapMessageType.MULTIMAP_ISLOCKED = 0x0212;
+    MultiMapMessageType.MULTIMAP_UNLOCK = 0x0213;
+    MultiMapMessageType.MULTIMAP_FORCEUNLOCK = 0x0214;
+    MultiMapMessageType.MULTIMAP_REMOVEENTRY = 0x0215;
+    return MultiMapMessageType;
+}());
+exports.MultiMapMessageType = MultiMapMessageType;

package/lib/codec/MultiMapPutCodec.d.ts

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

package/lib/codec/MultiMapPutCodec.js

@@ -0,0 +1,60 @@
+"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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_PUT;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var MultiMapPutCodec = /** @class */ (function () {
+    function MultiMapPutCodec() {
+    }
+    MultiMapPutCodec.calculateSize = function (name, key, value, threadId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(value);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapPutCodec.encodeRequest = function (name, key, value, threadId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, value, threadId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(threadId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapPutCodec.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 MultiMapPutCodec;
+}());
+exports.MultiMapPutCodec = MultiMapPutCodec;

package/lib/codec/MultiMapRemoveCodec.d.ts

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

package/lib/codec/MultiMapRemoveCodec.js

@@ -0,0 +1,65 @@
+"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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_REMOVE;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = false;
+var MultiMapRemoveCodec = /** @class */ (function () {
+    function MultiMapRemoveCodec() {
+    }
+    MultiMapRemoveCodec.calculateSize = function (name, key, threadId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapRemoveCodec.encodeRequest = function (name, key, threadId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, threadId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(threadId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapRemoveCodec.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 MultiMapRemoveCodec;
+}());
+exports.MultiMapRemoveCodec = MultiMapRemoveCodec;

package/lib/codec/MultiMapRemoveEntryCodec.d.ts

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