@celerispay/hazelcast-client 3.12.5

package/lib/codec/MapAddEntryListenerToKeyWithPredicateCodec.js

@@ -0,0 +1,108 @@
+"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_ADDENTRYLISTENERTOKEYWITHPREDICATE;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var MapAddEntryListenerToKeyWithPredicateCodec = /** @class */ (function () {
+    function MapAddEntryListenerToKeyWithPredicateCodec() {
+    }
+    MapAddEntryListenerToKeyWithPredicateCodec.calculateSize = function (name, key, predicate, includeValue, listenerFlags, localOnly) {
+        // 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(predicate);
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapAddEntryListenerToKeyWithPredicateCodec.encodeRequest = function (name, key, predicate, includeValue, listenerFlags, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, predicate, includeValue, listenerFlags, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(predicate);
+        clientMessage.appendBoolean(includeValue);
+        clientMessage.appendInt32(listenerFlags);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapAddEntryListenerToKeyWithPredicateCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readString();
+        return parameters;
+    };
+    MapAddEntryListenerToKeyWithPredicateCodec.handle = function (clientMessage, handleEventEntry, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_ENTRY && handleEventEntry !== null) {
+            var messageFinished = false;
+            var key = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    key = clientMessage.readData();
+                }
+            }
+            var value = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    value = clientMessage.readData();
+                }
+            }
+            var oldValue = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    oldValue = clientMessage.readData();
+                }
+            }
+            var mergingValue = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    mergingValue = clientMessage.readData();
+                }
+            }
+            var eventType = undefined;
+            if (!messageFinished) {
+                eventType = clientMessage.readInt32();
+            }
+            var uuid = undefined;
+            if (!messageFinished) {
+                uuid = clientMessage.readString();
+            }
+            var numberOfAffectedEntries = undefined;
+            if (!messageFinished) {
+                numberOfAffectedEntries = clientMessage.readInt32();
+            }
+            handleEventEntry(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
+        }
+    };
+    return MapAddEntryListenerToKeyWithPredicateCodec;
+}());
+exports.MapAddEntryListenerToKeyWithPredicateCodec = MapAddEntryListenerToKeyWithPredicateCodec;

package/lib/codec/MapAddEntryListenerWithPredicateCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapAddEntryListenerWithPredicateCodec {
+    static calculateSize(name: string, predicate: Data, includeValue: boolean, listenerFlags: number, localOnly: boolean): number;
+    static encodeRequest(name: string, predicate: Data, includeValue: boolean, listenerFlags: number, localOnly: boolean): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+    static handle(clientMessage: ClientMessage, handleEventEntry: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/MapAddEntryListenerWithPredicateCodec.js

@@ -0,0 +1,106 @@
+"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_ADDENTRYLISTENERWITHPREDICATE;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var MapAddEntryListenerWithPredicateCodec = /** @class */ (function () {
+    function MapAddEntryListenerWithPredicateCodec() {
+    }
+    MapAddEntryListenerWithPredicateCodec.calculateSize = function (name, predicate, includeValue, listenerFlags, localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(predicate);
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapAddEntryListenerWithPredicateCodec.encodeRequest = function (name, predicate, includeValue, listenerFlags, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, predicate, includeValue, listenerFlags, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(predicate);
+        clientMessage.appendBoolean(includeValue);
+        clientMessage.appendInt32(listenerFlags);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapAddEntryListenerWithPredicateCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readString();
+        return parameters;
+    };
+    MapAddEntryListenerWithPredicateCodec.handle = function (clientMessage, handleEventEntry, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_ENTRY && handleEventEntry !== null) {
+            var messageFinished = false;
+            var key = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    key = clientMessage.readData();
+                }
+            }
+            var value = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    value = clientMessage.readData();
+                }
+            }
+            var oldValue = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    oldValue = clientMessage.readData();
+                }
+            }
+            var mergingValue = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    mergingValue = clientMessage.readData();
+                }
+            }
+            var eventType = undefined;
+            if (!messageFinished) {
+                eventType = clientMessage.readInt32();
+            }
+            var uuid = undefined;
+            if (!messageFinished) {
+                uuid = clientMessage.readString();
+            }
+            var numberOfAffectedEntries = undefined;
+            if (!messageFinished) {
+                numberOfAffectedEntries = clientMessage.readInt32();
+            }
+            handleEventEntry(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
+        }
+    };
+    return MapAddEntryListenerWithPredicateCodec;
+}());
+exports.MapAddEntryListenerWithPredicateCodec = MapAddEntryListenerWithPredicateCodec;

package/lib/codec/MapAddIndexCodec.d.ts

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

package/lib/codec/MapAddIndexCodec.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_ADDINDEX;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var MapAddIndexCodec = /** @class */ (function () {
+    function MapAddIndexCodec() {
+    }
+    MapAddIndexCodec.calculateSize = function (name, attribute, ordered) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(attribute);
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapAddIndexCodec.encodeRequest = function (name, attribute, ordered) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, attribute, ordered));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendString(attribute);
+        clientMessage.appendBoolean(ordered);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MapAddIndexCodec;
+}());
+exports.MapAddIndexCodec = MapAddIndexCodec;

package/lib/codec/MapAddNearCacheEntryListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapAddNearCacheEntryListenerCodec {
+    static calculateSize(name: string, listenerFlags: number, localOnly: boolean): number;
+    static encodeRequest(name: string, listenerFlags: number, localOnly: boolean): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+    static handle(clientMessage: ClientMessage, handleEventImapinvalidation: any, handleEventImapbatchinvalidation: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/MapAddNearCacheEntryListenerCodec.js

@@ -0,0 +1,135 @@
+"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 UUIDCodec_1 = require("./UUIDCodec");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_ADDNEARCACHEENTRYLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var MapAddNearCacheEntryListenerCodec = /** @class */ (function () {
+    function MapAddNearCacheEntryListenerCodec() {
+    }
+    MapAddNearCacheEntryListenerCodec.calculateSize = function (name, listenerFlags, localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapAddNearCacheEntryListenerCodec.encodeRequest = function (name, listenerFlags, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, listenerFlags, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(listenerFlags);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapAddNearCacheEntryListenerCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readString();
+        return parameters;
+    };
+    MapAddNearCacheEntryListenerCodec.handle = function (clientMessage, handleEventImapinvalidation, handleEventImapbatchinvalidation, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_IMAPINVALIDATION && handleEventImapinvalidation !== null) {
+            var messageFinished = false;
+            var key = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    key = clientMessage.readData();
+                }
+            }
+            var sourceUuid = undefined;
+            if (!messageFinished) {
+                messageFinished = clientMessage.isComplete();
+            }
+            if (!messageFinished) {
+                sourceUuid = clientMessage.readString();
+            }
+            var partitionUuid = undefined;
+            if (!messageFinished) {
+                partitionUuid = UUIDCodec_1.UUIDCodec.decode(clientMessage, toObjectFunction);
+            }
+            var sequence = undefined;
+            if (!messageFinished) {
+                sequence = clientMessage.readLong();
+            }
+            handleEventImapinvalidation(key, sourceUuid, partitionUuid, sequence);
+        }
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_IMAPBATCHINVALIDATION && handleEventImapbatchinvalidation !== null) {
+            var messageFinished = false;
+            var keys = undefined;
+            if (!messageFinished) {
+                var keysSize = clientMessage.readInt32();
+                keys = [];
+                for (var keysIndex = 0; keysIndex < keysSize; keysIndex++) {
+                    var keysItem;
+                    keysItem = clientMessage.readData();
+                    keys.push(keysItem);
+                }
+            }
+            var sourceUuids = undefined;
+            if (!messageFinished) {
+                messageFinished = clientMessage.isComplete();
+            }
+            if (!messageFinished) {
+                var sourceUuidsSize = clientMessage.readInt32();
+                sourceUuids = [];
+                for (var sourceUuidsIndex = 0; sourceUuidsIndex < sourceUuidsSize; sourceUuidsIndex++) {
+                    var sourceUuidsItem;
+                    sourceUuidsItem = clientMessage.readString();
+                    sourceUuids.push(sourceUuidsItem);
+                }
+            }
+            var partitionUuids = undefined;
+            if (!messageFinished) {
+                var partitionUuidsSize = clientMessage.readInt32();
+                partitionUuids = [];
+                for (var partitionUuidsIndex = 0; partitionUuidsIndex < partitionUuidsSize; partitionUuidsIndex++) {
+                    var partitionUuidsItem;
+                    partitionUuidsItem = UUIDCodec_1.UUIDCodec.decode(clientMessage, toObjectFunction);
+                    partitionUuids.push(partitionUuidsItem);
+                }
+            }
+            var sequences = undefined;
+            if (!messageFinished) {
+                var sequencesSize = clientMessage.readInt32();
+                sequences = [];
+                for (var sequencesIndex = 0; sequencesIndex < sequencesSize; sequencesIndex++) {
+                    var sequencesItem;
+                    sequencesItem = clientMessage.readLong();
+                    sequences.push(sequencesItem);
+                }
+            }
+            handleEventImapbatchinvalidation(keys, sourceUuids, partitionUuids, sequences);
+        }
+    };
+    return MapAddNearCacheEntryListenerCodec;
+}());
+exports.MapAddNearCacheEntryListenerCodec = MapAddNearCacheEntryListenerCodec;

package/lib/codec/MapAddNearCacheInvalidationListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapAddNearCacheInvalidationListenerCodec {
+    static calculateSize(name: string, listenerFlags: number, localOnly: boolean): number;
+    static encodeRequest(name: string, listenerFlags: number, localOnly: boolean): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+    static handle(clientMessage: ClientMessage, handleEventImapinvalidation: any, handleEventImapbatchinvalidation: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/MapAddNearCacheInvalidationListenerCodec.js

@@ -0,0 +1,138 @@
+"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 UUIDCodec_1 = require("./UUIDCodec");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_ADDNEARCACHEINVALIDATIONLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var MapAddNearCacheInvalidationListenerCodec = /** @class */ (function () {
+    function MapAddNearCacheInvalidationListenerCodec() {
+    }
+    MapAddNearCacheInvalidationListenerCodec.calculateSize = function (name, listenerFlags, localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapAddNearCacheInvalidationListenerCodec.encodeRequest = function (name, listenerFlags, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, listenerFlags, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(listenerFlags);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapAddNearCacheInvalidationListenerCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        if (clientMessage.isComplete()) {
+            return parameters;
+        }
+        parameters['response'] = clientMessage.readString();
+        return parameters;
+    };
+    MapAddNearCacheInvalidationListenerCodec.handle = function (clientMessage, handleEventImapinvalidation, handleEventImapbatchinvalidation, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_IMAPINVALIDATION && handleEventImapinvalidation !== null) {
+            var messageFinished = false;
+            var key = undefined;
+            if (!messageFinished) {
+                messageFinished = clientMessage.isComplete();
+            }
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    key = clientMessage.readData();
+                }
+            }
+            var sourceUuid = undefined;
+            if (!messageFinished) {
+                sourceUuid = clientMessage.readString();
+            }
+            var partitionUuid = undefined;
+            if (!messageFinished) {
+                partitionUuid = UUIDCodec_1.UUIDCodec.decode(clientMessage, toObjectFunction);
+            }
+            var sequence = undefined;
+            if (!messageFinished) {
+                sequence = clientMessage.readLong();
+            }
+            handleEventImapinvalidation(key, sourceUuid, partitionUuid, sequence);
+        }
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_IMAPBATCHINVALIDATION && handleEventImapbatchinvalidation !== null) {
+            var messageFinished = false;
+            var keys = undefined;
+            if (!messageFinished) {
+                messageFinished = clientMessage.isComplete();
+            }
+            if (!messageFinished) {
+                var keysSize = clientMessage.readInt32();
+                keys = [];
+                for (var keysIndex = 0; keysIndex < keysSize; keysIndex++) {
+                    var keysItem;
+                    keysItem = clientMessage.readData();
+                    keys.push(keysItem);
+                }
+            }
+            var sourceUuids = undefined;
+            if (!messageFinished) {
+                var sourceUuidsSize = clientMessage.readInt32();
+                sourceUuids = [];
+                for (var sourceUuidsIndex = 0; sourceUuidsIndex < sourceUuidsSize; sourceUuidsIndex++) {
+                    var sourceUuidsItem;
+                    sourceUuidsItem = clientMessage.readString();
+                    sourceUuids.push(sourceUuidsItem);
+                }
+            }
+            var partitionUuids = undefined;
+            if (!messageFinished) {
+                var partitionUuidsSize = clientMessage.readInt32();
+                partitionUuids = [];
+                for (var partitionUuidsIndex = 0; partitionUuidsIndex < partitionUuidsSize; partitionUuidsIndex++) {
+                    var partitionUuidsItem;
+                    partitionUuidsItem = UUIDCodec_1.UUIDCodec.decode(clientMessage, toObjectFunction);
+                    partitionUuids.push(partitionUuidsItem);
+                }
+            }
+            var sequences = undefined;
+            if (!messageFinished) {
+                var sequencesSize = clientMessage.readInt32();
+                sequences = [];
+                for (var sequencesIndex = 0; sequencesIndex < sequencesSize; sequencesIndex++) {
+                    var sequencesItem;
+                    sequencesItem = clientMessage.readLong();
+                    sequences.push(sequencesItem);
+                }
+            }
+            handleEventImapbatchinvalidation(keys, sourceUuids, partitionUuids, sequences);
+        }
+    };
+    return MapAddNearCacheInvalidationListenerCodec;
+}());
+exports.MapAddNearCacheInvalidationListenerCodec = MapAddNearCacheInvalidationListenerCodec;

package/lib/codec/MapAggregateCodec.d.ts

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

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

package/lib/codec/MapAggregateWithPredicateCodec.d.ts

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