@celerispay/hazelcast-client 3.12.5

package/lib/codec/ReplicatedMapClearCodec.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 ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var ReplicatedMapMessageType_1 = require("./ReplicatedMapMessageType");
+var REQUEST_TYPE = ReplicatedMapMessageType_1.ReplicatedMapMessageType.REPLICATEDMAP_CLEAR;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var ReplicatedMapClearCodec = /** @class */ (function () {
+    function ReplicatedMapClearCodec() {
+    }
+    ReplicatedMapClearCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    ReplicatedMapClearCodec.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;
+    };
+    return ReplicatedMapClearCodec;
+}());
+exports.ReplicatedMapClearCodec = ReplicatedMapClearCodec;

package/lib/codec/ReplicatedMapContainsKeyCodec.d.ts

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

package/lib/codec/ReplicatedMapContainsValueCodec.d.ts

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

package/lib/codec/ReplicatedMapEntrySetCodec.d.ts

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

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

package/lib/codec/ReplicatedMapGetCodec.d.ts

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

package/lib/codec/ReplicatedMapIsEmptyCodec.d.ts

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

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

package/lib/codec/ReplicatedMapKeySetCodec.d.ts

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

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

package/lib/codec/ReplicatedMapMessageType.d.ts

@@ -0,0 +1,20 @@
+export declare class ReplicatedMapMessageType {
+    static REPLICATEDMAP_PUT: number;
+    static REPLICATEDMAP_SIZE: number;
+    static REPLICATEDMAP_ISEMPTY: number;
+    static REPLICATEDMAP_CONTAINSKEY: number;
+    static REPLICATEDMAP_CONTAINSVALUE: number;
+    static REPLICATEDMAP_GET: number;
+    static REPLICATEDMAP_REMOVE: number;
+    static REPLICATEDMAP_PUTALL: number;
+    static REPLICATEDMAP_CLEAR: number;
+    static REPLICATEDMAP_ADDENTRYLISTENERTOKEYWITHPREDICATE: number;
+    static REPLICATEDMAP_ADDENTRYLISTENERWITHPREDICATE: number;
+    static REPLICATEDMAP_ADDENTRYLISTENERTOKEY: number;
+    static REPLICATEDMAP_ADDENTRYLISTENER: number;
+    static REPLICATEDMAP_REMOVEENTRYLISTENER: number;
+    static REPLICATEDMAP_KEYSET: number;
+    static REPLICATEDMAP_VALUES: number;
+    static REPLICATEDMAP_ENTRYSET: number;
+    static REPLICATEDMAP_ADDNEARCACHEENTRYLISTENER: number;
+}

package/lib/codec/ReplicatedMapMessageType.js

@@ -0,0 +1,42 @@
+"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 ReplicatedMapMessageType = /** @class */ (function () {
+    function ReplicatedMapMessageType() {
+    }
+    ReplicatedMapMessageType.REPLICATEDMAP_PUT = 0x0e01;
+    ReplicatedMapMessageType.REPLICATEDMAP_SIZE = 0x0e02;
+    ReplicatedMapMessageType.REPLICATEDMAP_ISEMPTY = 0x0e03;
+    ReplicatedMapMessageType.REPLICATEDMAP_CONTAINSKEY = 0x0e04;
+    ReplicatedMapMessageType.REPLICATEDMAP_CONTAINSVALUE = 0x0e05;
+    ReplicatedMapMessageType.REPLICATEDMAP_GET = 0x0e06;
+    ReplicatedMapMessageType.REPLICATEDMAP_REMOVE = 0x0e07;
+    ReplicatedMapMessageType.REPLICATEDMAP_PUTALL = 0x0e08;
+    ReplicatedMapMessageType.REPLICATEDMAP_CLEAR = 0x0e09;
+    ReplicatedMapMessageType.REPLICATEDMAP_ADDENTRYLISTENERTOKEYWITHPREDICATE = 0x0e0a;
+    ReplicatedMapMessageType.REPLICATEDMAP_ADDENTRYLISTENERWITHPREDICATE = 0x0e0b;
+    ReplicatedMapMessageType.REPLICATEDMAP_ADDENTRYLISTENERTOKEY = 0x0e0c;
+    ReplicatedMapMessageType.REPLICATEDMAP_ADDENTRYLISTENER = 0x0e0d;
+    ReplicatedMapMessageType.REPLICATEDMAP_REMOVEENTRYLISTENER = 0x0e0e;
+    ReplicatedMapMessageType.REPLICATEDMAP_KEYSET = 0x0e0f;
+    ReplicatedMapMessageType.REPLICATEDMAP_VALUES = 0x0e10;
+    ReplicatedMapMessageType.REPLICATEDMAP_ENTRYSET = 0x0e11;
+    ReplicatedMapMessageType.REPLICATEDMAP_ADDNEARCACHEENTRYLISTENER = 0x0e12;
+    return ReplicatedMapMessageType;
+}());
+exports.ReplicatedMapMessageType = ReplicatedMapMessageType;

package/lib/codec/ReplicatedMapPutAllCodec.d.ts

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

package/lib/codec/ReplicatedMapPutAllCodec.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 ReplicatedMapMessageType_1 = require("./ReplicatedMapMessageType");
+var REQUEST_TYPE = ReplicatedMapMessageType_1.ReplicatedMapMessageType.REPLICATEDMAP_PUTALL;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var ReplicatedMapPutAllCodec = /** @class */ (function () {
+    function ReplicatedMapPutAllCodec() {
+    }
+    ReplicatedMapPutAllCodec.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;
+    };
+    ReplicatedMapPutAllCodec.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 ReplicatedMapPutAllCodec;
+}());
+exports.ReplicatedMapPutAllCodec = ReplicatedMapPutAllCodec;

package/lib/codec/ReplicatedMapPutCodec.d.ts

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

package/lib/codec/ReplicatedMapPutCodec.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 ReplicatedMapMessageType_1 = require("./ReplicatedMapMessageType");
+var REQUEST_TYPE = ReplicatedMapMessageType_1.ReplicatedMapMessageType.REPLICATEDMAP_PUT;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var ReplicatedMapPutCodec = /** @class */ (function () {
+    function ReplicatedMapPutCodec() {
+    }
+    ReplicatedMapPutCodec.calculateSize = function (name, key, value, 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;
+        return dataSize;
+    };
+    ReplicatedMapPutCodec.encodeRequest = function (name, key, value, ttl) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, value, ttl));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(ttl);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ReplicatedMapPutCodec.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 ReplicatedMapPutCodec;
+}());
+exports.ReplicatedMapPutCodec = ReplicatedMapPutCodec;

package/lib/codec/ReplicatedMapRemoveCodec.d.ts

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