@celerispay/hazelcast-client 3.12.5

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

package/lib/codec/QueueSizeCodec.d.ts

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

package/lib/codec/QueueSizeCodec.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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_SIZE;
+var RESPONSE_TYPE = 102;
+var RETRYABLE = false;
+var QueueSizeCodec = /** @class */ (function () {
+    function QueueSizeCodec() {
+    }
+    QueueSizeCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueueSizeCodec.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;
+    };
+    QueueSizeCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readInt32();
+        return parameters;
+    };
+    return QueueSizeCodec;
+}());
+exports.QueueSizeCodec = QueueSizeCodec;

package/lib/codec/QueueTakeCodec.d.ts

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

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

package/lib/codec/ReplicatedMapAddEntryListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ReplicatedMapAddEntryListenerCodec {
+    static calculateSize(name: string, localOnly: boolean): number;
+    static encodeRequest(name: string, 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/ReplicatedMapAddEntryListenerCodec.js

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

package/lib/codec/ReplicatedMapAddEntryListenerToKeyCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ReplicatedMapAddEntryListenerToKeyCodec {
+    static calculateSize(name: string, key: Data, localOnly: boolean): number;
+    static encodeRequest(name: string, key: Data, 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/ReplicatedMapAddEntryListenerToKeyCodec.js

@@ -0,0 +1,102 @@
+"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_ADDENTRYLISTENERTOKEY;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var ReplicatedMapAddEntryListenerToKeyCodec = /** @class */ (function () {
+    function ReplicatedMapAddEntryListenerToKeyCodec() {
+    }
+    ReplicatedMapAddEntryListenerToKeyCodec.calculateSize = function (name, key, 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.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest = function (name, key, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ReplicatedMapAddEntryListenerToKeyCodec.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;
+    };
+    ReplicatedMapAddEntryListenerToKeyCodec.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 ReplicatedMapAddEntryListenerToKeyCodec;
+}());
+exports.ReplicatedMapAddEntryListenerToKeyCodec = ReplicatedMapAddEntryListenerToKeyCodec;

package/lib/codec/ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ReplicatedMapAddEntryListenerToKeyWithPredicateCodec {
+    static calculateSize(name: string, key: Data, predicate: Data, localOnly: boolean): number;
+    static encodeRequest(name: string, key: Data, predicate: Data, 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/ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.js

@@ -0,0 +1,104 @@
+"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_ADDENTRYLISTENERTOKEYWITHPREDICATE;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var ReplicatedMapAddEntryListenerToKeyWithPredicateCodec = /** @class */ (function () {
+    function ReplicatedMapAddEntryListenerToKeyWithPredicateCodec() {
+    }
+    ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.calculateSize = function (name, key, predicate, 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;
+        return dataSize;
+    };
+    ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest = function (name, key, predicate, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, predicate, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(predicate);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.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;
+    };
+    ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.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 ReplicatedMapAddEntryListenerToKeyWithPredicateCodec;
+}());
+exports.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec;

package/lib/codec/ReplicatedMapAddEntryListenerWithPredicateCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ReplicatedMapAddEntryListenerWithPredicateCodec {
+    static calculateSize(name: string, predicate: Data, localOnly: boolean): number;
+    static encodeRequest(name: string, predicate: Data, 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/ReplicatedMapAddEntryListenerWithPredicateCodec.js

@@ -0,0 +1,102 @@
+"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_ADDENTRYLISTENERWITHPREDICATE;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var ReplicatedMapAddEntryListenerWithPredicateCodec = /** @class */ (function () {
+    function ReplicatedMapAddEntryListenerWithPredicateCodec() {
+    }
+    ReplicatedMapAddEntryListenerWithPredicateCodec.calculateSize = function (name, predicate, 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;
+        return dataSize;
+    };
+    ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest = function (name, predicate, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, predicate, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(predicate);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ReplicatedMapAddEntryListenerWithPredicateCodec.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;
+    };
+    ReplicatedMapAddEntryListenerWithPredicateCodec.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 ReplicatedMapAddEntryListenerWithPredicateCodec;
+}());
+exports.ReplicatedMapAddEntryListenerWithPredicateCodec = ReplicatedMapAddEntryListenerWithPredicateCodec;

package/lib/codec/ReplicatedMapClearCodec.d.ts

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