@celerispay/hazelcast-client 3.12.5

package/lib/codec/MapExecuteOnKeyCodec.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_EXECUTEONKEY;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var MapExecuteOnKeyCodec = /** @class */ (function () {
+    function MapExecuteOnKeyCodec() {
+    }
+    MapExecuteOnKeyCodec.calculateSize = function (name, entryProcessor, key, threadId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(entryProcessor);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapExecuteOnKeyCodec.encodeRequest = function (name, entryProcessor, key, threadId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, entryProcessor, key, threadId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(entryProcessor);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(threadId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapExecuteOnKeyCodec.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 MapExecuteOnKeyCodec;
+}());
+exports.MapExecuteOnKeyCodec = MapExecuteOnKeyCodec;

package/lib/codec/MapExecuteOnKeysCodec.d.ts

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

package/lib/codec/MapExecuteOnKeysCodec.js

@@ -0,0 +1,75 @@
+"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_EXECUTEONKEYS;
+var RESPONSE_TYPE = 117;
+var RETRYABLE = false;
+var MapExecuteOnKeysCodec = /** @class */ (function () {
+    function MapExecuteOnKeysCodec() {
+    }
+    MapExecuteOnKeysCodec.calculateSize = function (name, entryProcessor, keys) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(entryProcessor);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        keys.forEach(function (keysItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(keysItem);
+        });
+        return dataSize;
+    };
+    MapExecuteOnKeysCodec.encodeRequest = function (name, entryProcessor, keys) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, entryProcessor, keys));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(entryProcessor);
+        clientMessage.appendInt32(keys.length);
+        keys.forEach(function (keysItem) {
+            clientMessage.appendData(keysItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapExecuteOnKeysCodec.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 MapExecuteOnKeysCodec;
+}());
+exports.MapExecuteOnKeysCodec = MapExecuteOnKeysCodec;

package/lib/codec/MapExecuteWithPredicateCodec.d.ts

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

package/lib/codec/MapExecuteWithPredicateCodec.js

@@ -0,0 +1,69 @@
+"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_EXECUTEWITHPREDICATE;
+var RESPONSE_TYPE = 117;
+var RETRYABLE = false;
+var MapExecuteWithPredicateCodec = /** @class */ (function () {
+    function MapExecuteWithPredicateCodec() {
+    }
+    MapExecuteWithPredicateCodec.calculateSize = function (name, entryProcessor, predicate) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(entryProcessor);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(predicate);
+        return dataSize;
+    };
+    MapExecuteWithPredicateCodec.encodeRequest = function (name, entryProcessor, predicate) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, entryProcessor, predicate));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(entryProcessor);
+        clientMessage.appendData(predicate);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapExecuteWithPredicateCodec.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 MapExecuteWithPredicateCodec;
+}());
+exports.MapExecuteWithPredicateCodec = MapExecuteWithPredicateCodec;

package/lib/codec/MapFetchNearCacheInvalidationMetadataCodec.d.ts

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

package/lib/codec/MapFetchNearCacheInvalidationMetadataCodec.js

@@ -0,0 +1,101 @@
+"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 AddressCodec_1 = require("./AddressCodec");
+var UUIDCodec_1 = require("./UUIDCodec");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_FETCHNEARCACHEINVALIDATIONMETADATA;
+var RESPONSE_TYPE = 122;
+var RETRYABLE = false;
+var MapFetchNearCacheInvalidationMetadataCodec = /** @class */ (function () {
+    function MapFetchNearCacheInvalidationMetadataCodec() {
+    }
+    MapFetchNearCacheInvalidationMetadataCodec.calculateSize = function (names, address) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        names.forEach(function (namesItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeString(namesItem);
+        });
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeAddress(address);
+        return dataSize;
+    };
+    MapFetchNearCacheInvalidationMetadataCodec.encodeRequest = function (names, address) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(names, address));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendInt32(names.length);
+        names.forEach(function (namesItem) {
+            clientMessage.appendString(namesItem);
+        });
+        AddressCodec_1.AddressCodec.encode(clientMessage, address);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapFetchNearCacheInvalidationMetadataCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'namePartitionSequenceList': null,
+            'partitionUuidList': null
+        };
+        if (clientMessage.isComplete()) {
+            return parameters;
+        }
+        var namePartitionSequenceListSize = clientMessage.readInt32();
+        var namePartitionSequenceList = [];
+        for (var namePartitionSequenceListIndex = 0; namePartitionSequenceListIndex < namePartitionSequenceListSize; namePartitionSequenceListIndex++) {
+            var namePartitionSequenceListItem;
+            var namePartitionSequenceListItemKey;
+            var namePartitionSequenceListItemVal;
+            namePartitionSequenceListItemKey = clientMessage.readString();
+            var namePartitionSequenceListItemValSize = clientMessage.readInt32();
+            var namePartitionSequenceListItemVal = [];
+            for (var namePartitionSequenceListItemValIndex = 0; namePartitionSequenceListItemValIndex < namePartitionSequenceListItemValSize; namePartitionSequenceListItemValIndex++) {
+                var namePartitionSequenceListItemValItem;
+                var namePartitionSequenceListItemValItemKey;
+                var namePartitionSequenceListItemValItemVal;
+                namePartitionSequenceListItemValItemKey = clientMessage.readInt32();
+                namePartitionSequenceListItemValItemVal = clientMessage.readLong();
+                namePartitionSequenceListItemValItem = [namePartitionSequenceListItemValItemKey, namePartitionSequenceListItemValItemVal];
+                namePartitionSequenceListItemVal.push(namePartitionSequenceListItemValItem);
+            }
+            namePartitionSequenceListItem = [namePartitionSequenceListItemKey, namePartitionSequenceListItemVal];
+            namePartitionSequenceList.push(namePartitionSequenceListItem);
+        }
+        parameters['namePartitionSequenceList'] = namePartitionSequenceList;
+        var partitionUuidListSize = clientMessage.readInt32();
+        var partitionUuidList = [];
+        for (var partitionUuidListIndex = 0; partitionUuidListIndex < partitionUuidListSize; partitionUuidListIndex++) {
+            var partitionUuidListItem;
+            var partitionUuidListItemKey;
+            var partitionUuidListItemVal;
+            partitionUuidListItemKey = clientMessage.readInt32();
+            partitionUuidListItemVal = UUIDCodec_1.UUIDCodec.decode(clientMessage, toObjectFunction);
+            partitionUuidListItem = [partitionUuidListItemKey, partitionUuidListItemVal];
+            partitionUuidList.push(partitionUuidListItem);
+        }
+        parameters['partitionUuidList'] = partitionUuidList;
+        return parameters;
+    };
+    return MapFetchNearCacheInvalidationMetadataCodec;
+}());
+exports.MapFetchNearCacheInvalidationMetadataCodec = MapFetchNearCacheInvalidationMetadataCodec;

package/lib/codec/MapFlushCodec.d.ts

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

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

package/lib/codec/MapForceUnlockCodec.d.ts

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

package/lib/codec/MapForceUnlockCodec.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 MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_FORCEUNLOCK;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = true;
+var MapForceUnlockCodec = /** @class */ (function () {
+    function MapForceUnlockCodec() {
+    }
+    MapForceUnlockCodec.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;
+    };
+    MapForceUnlockCodec.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 MapForceUnlockCodec;
+}());
+exports.MapForceUnlockCodec = MapForceUnlockCodec;

package/lib/codec/MapGetAllCodec.d.ts

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

package/lib/codec/MapGetAllCodec.js

@@ -0,0 +1,73 @@
+"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_GETALL;
+var RESPONSE_TYPE = 117;
+var RETRYABLE = false;
+var MapGetAllCodec = /** @class */ (function () {
+    function MapGetAllCodec() {
+    }
+    MapGetAllCodec.calculateSize = function (name, keys) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        keys.forEach(function (keysItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(keysItem);
+        });
+        return dataSize;
+    };
+    MapGetAllCodec.encodeRequest = function (name, keys) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, keys));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(keys.length);
+        keys.forEach(function (keysItem) {
+            clientMessage.appendData(keysItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapGetAllCodec.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 MapGetAllCodec;
+}());
+exports.MapGetAllCodec = MapGetAllCodec;

package/lib/codec/MapGetCodec.d.ts

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

package/lib/codec/MapGetEntryViewCodec.d.ts

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