@celerispay/hazelcast-client 3.12.5

package/lib/codec/MapAggregateWithPredicateCodec.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_AGGREGATEWITHPREDICATE;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = true;
+var MapAggregateWithPredicateCodec = /** @class */ (function () {
+    function MapAggregateWithPredicateCodec() {
+    }
+    MapAggregateWithPredicateCodec.calculateSize = function (name, aggregator, predicate) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(aggregator);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(predicate);
+        return dataSize;
+    };
+    MapAggregateWithPredicateCodec.encodeRequest = function (name, aggregator, predicate) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, aggregator, predicate));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(aggregator);
+        clientMessage.appendData(predicate);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapAggregateWithPredicateCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        if (clientMessage.isComplete()) {
+            return parameters;
+        }
+        if (clientMessage.readBoolean() !== true) {
+            parameters['response'] = toObjectFunction(clientMessage.readData());
+        }
+        return parameters;
+    };
+    return MapAggregateWithPredicateCodec;
+}());
+exports.MapAggregateWithPredicateCodec = MapAggregateWithPredicateCodec;

package/lib/codec/MapClearCodec.d.ts

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

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

package/lib/codec/MapContainsKeyCodec.d.ts

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

package/lib/codec/MapContainsValueCodec.d.ts

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

package/lib/codec/MapDeleteCodec.d.ts

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

package/lib/codec/MapDeleteCodec.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_DELETE;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var MapDeleteCodec = /** @class */ (function () {
+    function MapDeleteCodec() {
+    }
+    MapDeleteCodec.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;
+    };
+    MapDeleteCodec.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;
+    };
+    return MapDeleteCodec;
+}());
+exports.MapDeleteCodec = MapDeleteCodec;

package/lib/codec/MapEntriesWithPredicateCodec.d.ts

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

package/lib/codec/MapEntriesWithPredicateCodec.js

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

package/lib/codec/MapEntrySetCodec.d.ts

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

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

package/lib/codec/MapEvictAllCodec.d.ts

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

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

package/lib/codec/MapEvictCodec.d.ts

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

package/lib/codec/MapExecuteOnAllKeysCodec.d.ts

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

package/lib/codec/MapExecuteOnAllKeysCodec.js

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

package/lib/codec/MapExecuteOnKeyCodec.d.ts

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