@celerispay/hazelcast-client 3.12.5

package/lib/codec/DistributedObjectInfoCodec.js

@@ -0,0 +1,27 @@
+"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.
+ */
+var DistributedObjectInfoCodec = /** @class */ (function () {
+    function DistributedObjectInfoCodec() {
+    }
+    DistributedObjectInfoCodec.decode = function (clientMessage, toObjectFunction) {
+        var serviceName = clientMessage.readString();
+        var name = clientMessage.readString();
+        return { key: serviceName, value: name };
+    };
+    return DistributedObjectInfoCodec;
+}());
+module.exports = DistributedObjectInfoCodec;

package/lib/codec/EntryViewCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+import { EntryView } from '../core/EntryView';
+export declare class EntryViewCodec {
+    static encode(clientMessage: ClientMessage, entryView: EntryView<any, any>, toData?: (object: any) => Data): void;
+    static decode(clientMessage: ClientMessage, toObject?: (data: Data) => any): EntryView<any, any>;
+}

package/lib/codec/EntryViewCodec.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 });
+var EntryView_1 = require("../core/EntryView");
+var EntryViewCodec = /** @class */ (function () {
+    function EntryViewCodec() {
+    }
+    EntryViewCodec.encode = function (clientMessage, entryView, toData) {
+        if (toData === void 0) { toData = null; }
+        clientMessage.appendData(toData(entryView.key));
+        clientMessage.appendData(toData(entryView.value));
+        clientMessage.appendLong(entryView.cost);
+        clientMessage.appendLong(entryView.creationTime);
+        clientMessage.appendLong(entryView.expirationTime);
+        clientMessage.appendLong(entryView.hits);
+        clientMessage.appendLong(entryView.lastAccessTime);
+        clientMessage.appendLong(entryView.lastStoreTime);
+        clientMessage.appendLong(entryView.lastUpdateTime);
+        clientMessage.appendLong(entryView.version);
+        clientMessage.appendLong(entryView.evictionCriteriaNumber);
+        clientMessage.appendLong(entryView.ttl);
+    };
+    EntryViewCodec.decode = function (clientMessage, toObject) {
+        if (toObject === void 0) { toObject = null; }
+        var entry = new EntryView_1.EntryView();
+        entry.key = toObject(clientMessage.readData());
+        entry.value = toObject(clientMessage.readData());
+        entry.cost = clientMessage.readLong();
+        entry.creationTime = clientMessage.readLong();
+        entry.expirationTime = clientMessage.readLong();
+        entry.hits = clientMessage.readLong();
+        entry.lastAccessTime = clientMessage.readLong();
+        entry.lastStoreTime = clientMessage.readLong();
+        entry.lastUpdateTime = clientMessage.readLong();
+        entry.version = clientMessage.readLong();
+        entry.evictionCriteriaNumber = clientMessage.readLong();
+        entry.ttl = clientMessage.readLong();
+        return entry;
+    };
+    return EntryViewCodec;
+}());
+exports.EntryViewCodec = EntryViewCodec;

package/lib/codec/FlakeIdGeneratorMessageType.d.ts

@@ -0,0 +1,3 @@
+export declare class FlakeIdGeneratorMessageType {
+    static FLAKEIDGENERATOR_NEWIDBATCH: number;
+}

package/lib/codec/FlakeIdGeneratorMessageType.js

@@ -0,0 +1,25 @@
+"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 FlakeIdGeneratorMessageType = /** @class */ (function () {
+    function FlakeIdGeneratorMessageType() {
+    }
+    FlakeIdGeneratorMessageType.FLAKEIDGENERATOR_NEWIDBATCH = 0x1f01;
+    return FlakeIdGeneratorMessageType;
+}());
+exports.FlakeIdGeneratorMessageType = FlakeIdGeneratorMessageType;

package/lib/codec/FlakeIdGeneratorNewIdBatchCodec.d.ts

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

package/lib/codec/FlakeIdGeneratorNewIdBatchCodec.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 FlakeIdGeneratorMessageType_1 = require("./FlakeIdGeneratorMessageType");
+var REQUEST_TYPE = FlakeIdGeneratorMessageType_1.FlakeIdGeneratorMessageType.FLAKEIDGENERATOR_NEWIDBATCH;
+var RESPONSE_TYPE = 126;
+var RETRYABLE = true;
+var FlakeIdGeneratorNewIdBatchCodec = /** @class */ (function () {
+    function FlakeIdGeneratorNewIdBatchCodec() {
+    }
+    FlakeIdGeneratorNewIdBatchCodec.calculateSize = function (name, batchSize) {
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    FlakeIdGeneratorNewIdBatchCodec.encodeRequest = function (name, batchSize) {
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, batchSize));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(batchSize);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    FlakeIdGeneratorNewIdBatchCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var parameters = {
+            'base': null,
+            'increment': null,
+            'batchSize': null
+        };
+        if (clientMessage.isComplete()) {
+            return parameters;
+        }
+        parameters['base'] = clientMessage.readLong();
+        parameters['increment'] = clientMessage.readLong();
+        parameters['batchSize'] = clientMessage.readInt32();
+        return parameters;
+    };
+    return FlakeIdGeneratorNewIdBatchCodec;
+}());
+exports.FlakeIdGeneratorNewIdBatchCodec = FlakeIdGeneratorNewIdBatchCodec;

package/lib/codec/GetPartitionsCodec.d.ts

@@ -0,0 +1,9 @@
+import ClientMessage = require('../ClientMessage');
+import Address = require('../Address');
+declare class GetPartitionsCodec {
+    static encodeRequest(): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage): {
+        [partitionId: number]: Address;
+    };
+}
+export = GetPartitionsCodec;

package/lib/codec/GetPartitionsCodec.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.
+ */
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var Address = require("../Address");
+var GetPartitionsCodec = /** @class */ (function () {
+    function GetPartitionsCodec() {
+    }
+    GetPartitionsCodec.encodeRequest = function () {
+        var clientMessage = ClientMessage.newClientMessage(0);
+        clientMessage.setMessageType(0x0008);
+        return clientMessage;
+    };
+    GetPartitionsCodec.decodeResponse = function (clientMessage) {
+        var result = {};
+        var size = clientMessage.readInt32();
+        for (var i = 0; i < size; i++) {
+            var host = clientMessage.readString();
+            var port = clientMessage.readInt32();
+            var address = new Address(host, port);
+            var partitionCount = clientMessage.readInt32();
+            for (var j = 0; j < partitionCount; j++) {
+                var partitionId = clientMessage.readInt32();
+                result[partitionId] = address;
+            }
+        }
+        return result;
+    };
+    return GetPartitionsCodec;
+}());
+module.exports = GetPartitionsCodec;

package/lib/codec/ListAddAllCodec.d.ts

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

package/lib/codec/ListAddAllCodec.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var ListMessageType_1 = require("./ListMessageType");
+var REQUEST_TYPE = ListMessageType_1.ListMessageType.LIST_ADDALL;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var ListAddAllCodec = /** @class */ (function () {
+    function ListAddAllCodec() {
+    }
+    ListAddAllCodec.calculateSize = function (name, valueList) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        valueList.forEach(function (valueListItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(valueListItem);
+        });
+        return dataSize;
+    };
+    ListAddAllCodec.encodeRequest = function (name, valueList) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, valueList));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(valueList.length);
+        valueList.forEach(function (valueListItem) {
+            clientMessage.appendData(valueListItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ListAddAllCodec.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 ListAddAllCodec;
+}());
+exports.ListAddAllCodec = ListAddAllCodec;

package/lib/codec/ListAddAllWithIndexCodec.d.ts

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

package/lib/codec/ListAddAllWithIndexCodec.js

@@ -0,0 +1,64 @@
+"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 ListMessageType_1 = require("./ListMessageType");
+var REQUEST_TYPE = ListMessageType_1.ListMessageType.LIST_ADDALLWITHINDEX;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var ListAddAllWithIndexCodec = /** @class */ (function () {
+    function ListAddAllWithIndexCodec() {
+    }
+    ListAddAllWithIndexCodec.calculateSize = function (name, index, valueList) {
+        // 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.INT_SIZE_IN_BYTES;
+        valueList.forEach(function (valueListItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(valueListItem);
+        });
+        return dataSize;
+    };
+    ListAddAllWithIndexCodec.encodeRequest = function (name, index, valueList) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, index, valueList));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(index);
+        clientMessage.appendInt32(valueList.length);
+        valueList.forEach(function (valueListItem) {
+            clientMessage.appendData(valueListItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ListAddAllWithIndexCodec.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 ListAddAllWithIndexCodec;
+}());
+exports.ListAddAllWithIndexCodec = ListAddAllWithIndexCodec;

package/lib/codec/ListAddCodec.d.ts

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

package/lib/codec/ListAddListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ListAddListenerCodec {
+    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, handleEventItem: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/ListAddListenerCodec.js

@@ -0,0 +1,80 @@
+"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 ListMessageType_1 = require("./ListMessageType");
+var REQUEST_TYPE = ListMessageType_1.ListMessageType.LIST_ADDLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var ListAddListenerCodec = /** @class */ (function () {
+    function ListAddListenerCodec() {
+    }
+    ListAddListenerCodec.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;
+    };
+    ListAddListenerCodec.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;
+    };
+    ListAddListenerCodec.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;
+    };
+    ListAddListenerCodec.handle = function (clientMessage, handleEventItem, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_ITEM && handleEventItem !== null) {
+            var messageFinished = false;
+            var item = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    item = clientMessage.readData();
+                }
+            }
+            var uuid = undefined;
+            if (!messageFinished) {
+                uuid = clientMessage.readString();
+            }
+            var eventType = undefined;
+            if (!messageFinished) {
+                eventType = clientMessage.readInt32();
+            }
+            handleEventItem(item, uuid, eventType);
+        }
+    };
+    return ListAddListenerCodec;
+}());
+exports.ListAddListenerCodec = ListAddListenerCodec;

package/lib/codec/ListAddWithIndexCodec.d.ts

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

package/lib/codec/ListAddWithIndexCodec.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 ListMessageType_1 = require("./ListMessageType");
+var REQUEST_TYPE = ListMessageType_1.ListMessageType.LIST_ADDWITHINDEX;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var ListAddWithIndexCodec = /** @class */ (function () {
+    function ListAddWithIndexCodec() {
+    }
+    ListAddWithIndexCodec.calculateSize = function (name, index, value) {
+        // 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.calculateSizeData(value);
+        return dataSize;
+    };
+    ListAddWithIndexCodec.encodeRequest = function (name, index, value) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, index, value));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(index);
+        clientMessage.appendData(value);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return ListAddWithIndexCodec;
+}());
+exports.ListAddWithIndexCodec = ListAddWithIndexCodec;

package/lib/codec/ListClearCodec.d.ts

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

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