@celerispay/hazelcast-client 3.12.5

package/lib/codec/MapMessageType.js

@@ -0,0 +1,93 @@
+"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 MapMessageType = /** @class */ (function () {
+    function MapMessageType() {
+    }
+    MapMessageType.MAP_PUT = 0x0101;
+    MapMessageType.MAP_GET = 0x0102;
+    MapMessageType.MAP_REMOVE = 0x0103;
+    MapMessageType.MAP_REPLACE = 0x0104;
+    MapMessageType.MAP_REPLACEIFSAME = 0x0105;
+    MapMessageType.MAP_CONTAINSKEY = 0x0109;
+    MapMessageType.MAP_CONTAINSVALUE = 0x010a;
+    MapMessageType.MAP_REMOVEIFSAME = 0x010b;
+    MapMessageType.MAP_DELETE = 0x010c;
+    MapMessageType.MAP_FLUSH = 0x010d;
+    MapMessageType.MAP_TRYREMOVE = 0x010e;
+    MapMessageType.MAP_TRYPUT = 0x010f;
+    MapMessageType.MAP_PUTTRANSIENT = 0x0110;
+    MapMessageType.MAP_PUTIFABSENT = 0x0111;
+    MapMessageType.MAP_SET = 0x0112;
+    MapMessageType.MAP_LOCK = 0x0113;
+    MapMessageType.MAP_TRYLOCK = 0x0114;
+    MapMessageType.MAP_ISLOCKED = 0x0115;
+    MapMessageType.MAP_UNLOCK = 0x0116;
+    MapMessageType.MAP_ADDINTERCEPTOR = 0x0117;
+    MapMessageType.MAP_REMOVEINTERCEPTOR = 0x0118;
+    MapMessageType.MAP_ADDENTRYLISTENERTOKEYWITHPREDICATE = 0x0119;
+    MapMessageType.MAP_ADDENTRYLISTENERWITHPREDICATE = 0x011a;
+    MapMessageType.MAP_ADDENTRYLISTENERTOKEY = 0x011b;
+    MapMessageType.MAP_ADDENTRYLISTENER = 0x011c;
+    MapMessageType.MAP_ADDNEARCACHEENTRYLISTENER = 0x011d;
+    MapMessageType.MAP_REMOVEENTRYLISTENER = 0x011e;
+    MapMessageType.MAP_ADDPARTITIONLOSTLISTENER = 0x011f;
+    MapMessageType.MAP_REMOVEPARTITIONLOSTLISTENER = 0x0120;
+    MapMessageType.MAP_GETENTRYVIEW = 0x0121;
+    MapMessageType.MAP_EVICT = 0x0122;
+    MapMessageType.MAP_EVICTALL = 0x0123;
+    MapMessageType.MAP_LOADALL = 0x0124;
+    MapMessageType.MAP_LOADGIVENKEYS = 0x0125;
+    MapMessageType.MAP_KEYSET = 0x0126;
+    MapMessageType.MAP_GETALL = 0x0127;
+    MapMessageType.MAP_VALUES = 0x0128;
+    MapMessageType.MAP_ENTRYSET = 0x0129;
+    MapMessageType.MAP_KEYSETWITHPREDICATE = 0x012a;
+    MapMessageType.MAP_VALUESWITHPREDICATE = 0x012b;
+    MapMessageType.MAP_ENTRIESWITHPREDICATE = 0x012c;
+    MapMessageType.MAP_ADDINDEX = 0x012d;
+    MapMessageType.MAP_SIZE = 0x012e;
+    MapMessageType.MAP_ISEMPTY = 0x012f;
+    MapMessageType.MAP_PUTALL = 0x0130;
+    MapMessageType.MAP_CLEAR = 0x0131;
+    MapMessageType.MAP_EXECUTEONKEY = 0x0132;
+    MapMessageType.MAP_SUBMITTOKEY = 0x0133;
+    MapMessageType.MAP_EXECUTEONALLKEYS = 0x0134;
+    MapMessageType.MAP_EXECUTEWITHPREDICATE = 0x0135;
+    MapMessageType.MAP_EXECUTEONKEYS = 0x0136;
+    MapMessageType.MAP_FORCEUNLOCK = 0x0137;
+    MapMessageType.MAP_KEYSETWITHPAGINGPREDICATE = 0x0138;
+    MapMessageType.MAP_VALUESWITHPAGINGPREDICATE = 0x0139;
+    MapMessageType.MAP_ENTRIESWITHPAGINGPREDICATE = 0x013a;
+    MapMessageType.MAP_CLEARNEARCACHE = 0x013b;
+    MapMessageType.MAP_FETCHKEYS = 0x013c;
+    MapMessageType.MAP_FETCHENTRIES = 0x013d;
+    MapMessageType.MAP_AGGREGATE = 0x013e;
+    MapMessageType.MAP_AGGREGATEWITHPREDICATE = 0x013f;
+    MapMessageType.MAP_PROJECT = 0x0140;
+    MapMessageType.MAP_PROJECTWITHPREDICATE = 0x0141;
+    MapMessageType.MAP_FETCHNEARCACHEINVALIDATIONMETADATA = 0x0142;
+    MapMessageType.MAP_ASSIGNANDGETUUIDS = 0x0143;
+    MapMessageType.MAP_REMOVEALL = 0x0144;
+    MapMessageType.MAP_ADDNEARCACHEINVALIDATIONLISTENER = 0x0145;
+    MapMessageType.MAP_FETCHWITHQUERY = 0x0146;
+    MapMessageType.MAP_EVENTJOURNALSUBSCRIBE = 0x0147;
+    MapMessageType.MAP_EVENTJOURNALREAD = 0x0148;
+    return MapMessageType;
+}());
+exports.MapMessageType = MapMessageType;

package/lib/codec/MapPutAllCodec.d.ts

@@ -0,0 +1,5 @@
+import ClientMessage = require('../ClientMessage');
+export declare class MapPutAllCodec {
+    static calculateSize(name: string, entries: any): number;
+    static encodeRequest(name: string, entries: any): ClientMessage;
+}

package/lib/codec/MapPutAllCodec.js

@@ -0,0 +1,59 @@
+"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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_PUTALL;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var MapPutAllCodec = /** @class */ (function () {
+    function MapPutAllCodec() {
+    }
+    MapPutAllCodec.calculateSize = function (name, entries) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        entries.forEach(function (entriesItem) {
+            var key = entriesItem[0];
+            var val = entriesItem[1];
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(val);
+        });
+        return dataSize;
+    };
+    MapPutAllCodec.encodeRequest = function (name, entries) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, entries));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(entries.length);
+        entries.forEach(function (entriesItem) {
+            var key = entriesItem[0];
+            var val = entriesItem[1];
+            clientMessage.appendData(key);
+            clientMessage.appendData(val);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MapPutAllCodec;
+}());
+exports.MapPutAllCodec = MapPutAllCodec;

package/lib/codec/MapPutCodec.d.ts

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

package/lib/codec/MapPutCodec.js

@@ -0,0 +1,64 @@
+"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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_PUT;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var MapPutCodec = /** @class */ (function () {
+    function MapPutCodec() {
+    }
+    MapPutCodec.calculateSize = function (name, key, value, threadId, ttl) {
+        // 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;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapPutCodec.encodeRequest = function (name, key, value, threadId, ttl) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, value, threadId, ttl));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(threadId);
+        clientMessage.appendLong(ttl);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapPutCodec.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 MapPutCodec;
+}());
+exports.MapPutCodec = MapPutCodec;

package/lib/codec/MapPutIfAbsentCodec.d.ts

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

package/lib/codec/MapPutIfAbsentCodec.js

@@ -0,0 +1,64 @@
+"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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_PUTIFABSENT;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var MapPutIfAbsentCodec = /** @class */ (function () {
+    function MapPutIfAbsentCodec() {
+    }
+    MapPutIfAbsentCodec.calculateSize = function (name, key, value, threadId, ttl) {
+        // 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;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapPutIfAbsentCodec.encodeRequest = function (name, key, value, threadId, ttl) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, value, threadId, ttl));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(threadId);
+        clientMessage.appendLong(ttl);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapPutIfAbsentCodec.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 MapPutIfAbsentCodec;
+}());
+exports.MapPutIfAbsentCodec = MapPutIfAbsentCodec;

package/lib/codec/MapPutTransientCodec.d.ts

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

package/lib/codec/MapPutTransientCodec.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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_PUTTRANSIENT;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var MapPutTransientCodec = /** @class */ (function () {
+    function MapPutTransientCodec() {
+    }
+    MapPutTransientCodec.calculateSize = function (name, key, value, threadId, ttl) {
+        // 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;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapPutTransientCodec.encodeRequest = function (name, key, value, threadId, ttl) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, value, threadId, ttl));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(threadId);
+        clientMessage.appendLong(ttl);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MapPutTransientCodec;
+}());
+exports.MapPutTransientCodec = MapPutTransientCodec;

package/lib/codec/MapRemoveCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapRemoveCodec {
+    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/MapRemoveCodec.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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_REMOVE;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var MapRemoveCodec = /** @class */ (function () {
+    function MapRemoveCodec() {
+    }
+    MapRemoveCodec.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;
+    };
+    MapRemoveCodec.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;
+    };
+    MapRemoveCodec.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 MapRemoveCodec;
+}());
+exports.MapRemoveCodec = MapRemoveCodec;

package/lib/codec/MapRemoveEntryListenerCodec.d.ts

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

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

package/lib/codec/MapRemoveIfSameCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapRemoveIfSameCodec {
+    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/MapRemoveIfSameCodec.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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_REMOVEIFSAME;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var MapRemoveIfSameCodec = /** @class */ (function () {
+    function MapRemoveIfSameCodec() {
+    }
+    MapRemoveIfSameCodec.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;
+    };
+    MapRemoveIfSameCodec.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;
+    };
+    MapRemoveIfSameCodec.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 MapRemoveIfSameCodec;
+}());
+exports.MapRemoveIfSameCodec = MapRemoveIfSameCodec;

package/lib/codec/MapReplaceCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapReplaceCodec {
+    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/MapReplaceCodec.js

@@ -0,0 +1,62 @@
+"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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_REPLACE;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var MapReplaceCodec = /** @class */ (function () {
+    function MapReplaceCodec() {
+    }
+    MapReplaceCodec.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;
+    };
+    MapReplaceCodec.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;
+    };
+    MapReplaceCodec.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 MapReplaceCodec;
+}());
+exports.MapReplaceCodec = MapReplaceCodec;

package/lib/codec/MapReplaceIfSameCodec.d.ts

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