@celerispay/hazelcast-client 3.12.5

package/lib/codec/MapValuesWithPredicateCodec.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_VALUESWITHPREDICATE;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = true;
+var MapValuesWithPredicateCodec = /** @class */ (function () {
+    function MapValuesWithPredicateCodec() {
+    }
+    MapValuesWithPredicateCodec.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;
+    };
+    MapValuesWithPredicateCodec.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;
+    };
+    MapValuesWithPredicateCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        var responseSize = clientMessage.readInt32();
+        var response = [];
+        for (var responseIndex = 0; responseIndex < responseSize; responseIndex++) {
+            var responseItem;
+            responseItem = clientMessage.readData();
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return MapValuesWithPredicateCodec;
+}());
+exports.MapValuesWithPredicateCodec = MapValuesWithPredicateCodec;

package/lib/codec/MemberCodec.d.ts

@@ -0,0 +1,6 @@
+import ClientMessage = require('../ClientMessage');
+import { Member } from '../core/Member';
+export declare class MemberCodec {
+    static encode(clientMessage: ClientMessage, member: Member): void;
+    static decode(clientMessage: ClientMessage, toObject: Function): Member;
+}

package/lib/codec/MemberCodec.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 });
+var Member_1 = require("../core/Member");
+var AddressCodec_1 = require("./AddressCodec");
+var MemberCodec = /** @class */ (function () {
+    function MemberCodec() {
+    }
+    MemberCodec.encode = function (clientMessage, member) {
+        AddressCodec_1.AddressCodec.encode(clientMessage, member.address);
+        clientMessage.appendString(member.uuid);
+        clientMessage.appendBoolean(member.isLiteMember);
+        var keys = Object.keys(member.attributes);
+        clientMessage.appendInt32(keys.length);
+        for (var key in keys) {
+            clientMessage.appendString(key);
+            clientMessage.appendString(member.attributes[key]);
+        }
+    };
+    MemberCodec.decode = function (clientMessage, toObject) {
+        var address = AddressCodec_1.AddressCodec.decode(clientMessage, toObject);
+        var uuid = clientMessage.readString();
+        var liteMember = clientMessage.readBoolean();
+        var attributeSize = clientMessage.readInt32();
+        var attributes = {};
+        for (var i = 0; i < attributeSize; i++) {
+            var key = clientMessage.readString();
+            var val = clientMessage.readString();
+            attributes[key] = val;
+        }
+        return new Member_1.Member(address, uuid, liteMember, attributes);
+    };
+    return MemberCodec;
+}());
+exports.MemberCodec = MemberCodec;

package/lib/codec/MultiMapAddEntryListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MultiMapAddEntryListenerCodec {
+    static calculateSize(name: string, includeValue: boolean, localOnly: boolean): number;
+    static encodeRequest(name: string, includeValue: boolean, 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/MultiMapAddEntryListenerCodec.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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_ADDENTRYLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var MultiMapAddEntryListenerCodec = /** @class */ (function () {
+    function MultiMapAddEntryListenerCodec() {
+    }
+    MultiMapAddEntryListenerCodec.calculateSize = function (name, includeValue, localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapAddEntryListenerCodec.encodeRequest = function (name, includeValue, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, includeValue, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendBoolean(includeValue);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapAddEntryListenerCodec.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;
+    };
+    MultiMapAddEntryListenerCodec.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 MultiMapAddEntryListenerCodec;
+}());
+exports.MultiMapAddEntryListenerCodec = MultiMapAddEntryListenerCodec;

package/lib/codec/MultiMapAddEntryListenerToKeyCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MultiMapAddEntryListenerToKeyCodec {
+    static calculateSize(name: string, key: Data, includeValue: boolean, localOnly: boolean): number;
+    static encodeRequest(name: string, key: Data, includeValue: boolean, 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/MultiMapAddEntryListenerToKeyCodec.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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_ADDENTRYLISTENERTOKEY;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var MultiMapAddEntryListenerToKeyCodec = /** @class */ (function () {
+    function MultiMapAddEntryListenerToKeyCodec() {
+    }
+    MultiMapAddEntryListenerToKeyCodec.calculateSize = function (name, key, includeValue, 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;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapAddEntryListenerToKeyCodec.encodeRequest = function (name, key, includeValue, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, includeValue, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendBoolean(includeValue);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapAddEntryListenerToKeyCodec.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;
+    };
+    MultiMapAddEntryListenerToKeyCodec.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 MultiMapAddEntryListenerToKeyCodec;
+}());
+exports.MultiMapAddEntryListenerToKeyCodec = MultiMapAddEntryListenerToKeyCodec;

package/lib/codec/MultiMapClearCodec.d.ts

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

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

package/lib/codec/MultiMapContainsEntryCodec.d.ts

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

package/lib/codec/MultiMapContainsEntryCodec.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 MultiMapMessageType_1 = require("./MultiMapMessageType");
+var REQUEST_TYPE = MultiMapMessageType_1.MultiMapMessageType.MULTIMAP_CONTAINSENTRY;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = true;
+var MultiMapContainsEntryCodec = /** @class */ (function () {
+    function MultiMapContainsEntryCodec() {
+    }
+    MultiMapContainsEntryCodec.calculateSize = function (name, key, value, 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.calculateSizeData(value);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MultiMapContainsEntryCodec.encodeRequest = function (name, key, value, threadId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, value, threadId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendData(value);
+        clientMessage.appendLong(threadId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MultiMapContainsEntryCodec.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 MultiMapContainsEntryCodec;
+}());
+exports.MultiMapContainsEntryCodec = MultiMapContainsEntryCodec;

package/lib/codec/MultiMapContainsKeyCodec.d.ts

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

package/lib/codec/MultiMapContainsValueCodec.d.ts

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

package/lib/codec/MultiMapEntrySetCodec.d.ts

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