@celerispay/hazelcast-client 3.12.5

package/lib/codec/ListMessageType.js

@@ -0,0 +1,47 @@
+"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 ListMessageType = /** @class */ (function () {
+    function ListMessageType() {
+    }
+    ListMessageType.LIST_SIZE = 0x0501;
+    ListMessageType.LIST_CONTAINS = 0x0502;
+    ListMessageType.LIST_CONTAINSALL = 0x0503;
+    ListMessageType.LIST_ADD = 0x0504;
+    ListMessageType.LIST_REMOVE = 0x0505;
+    ListMessageType.LIST_ADDALL = 0x0506;
+    ListMessageType.LIST_COMPAREANDREMOVEALL = 0x0507;
+    ListMessageType.LIST_COMPAREANDRETAINALL = 0x0508;
+    ListMessageType.LIST_CLEAR = 0x0509;
+    ListMessageType.LIST_GETALL = 0x050a;
+    ListMessageType.LIST_ADDLISTENER = 0x050b;
+    ListMessageType.LIST_REMOVELISTENER = 0x050c;
+    ListMessageType.LIST_ISEMPTY = 0x050d;
+    ListMessageType.LIST_ADDALLWITHINDEX = 0x050e;
+    ListMessageType.LIST_GET = 0x050f;
+    ListMessageType.LIST_SET = 0x0510;
+    ListMessageType.LIST_ADDWITHINDEX = 0x0511;
+    ListMessageType.LIST_REMOVEWITHINDEX = 0x0512;
+    ListMessageType.LIST_LASTINDEXOF = 0x0513;
+    ListMessageType.LIST_INDEXOF = 0x0514;
+    ListMessageType.LIST_SUB = 0x0515;
+    ListMessageType.LIST_ITERATOR = 0x0516;
+    ListMessageType.LIST_LISTITERATOR = 0x0517;
+    return ListMessageType;
+}());
+exports.ListMessageType = ListMessageType;

package/lib/codec/ListRemoveCodec.d.ts

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

package/lib/codec/ListRemoveListenerCodec.d.ts

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

package/lib/codec/ListRemoveListenerCodec.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_REMOVELISTENER;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = true;
+var ListRemoveListenerCodec = /** @class */ (function () {
+    function ListRemoveListenerCodec() {
+    }
+    ListRemoveListenerCodec.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;
+    };
+    ListRemoveListenerCodec.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;
+    };
+    ListRemoveListenerCodec.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 ListRemoveListenerCodec;
+}());
+exports.ListRemoveListenerCodec = ListRemoveListenerCodec;

package/lib/codec/ListRemoveWithIndexCodec.d.ts

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

package/lib/codec/ListRemoveWithIndexCodec.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 ListMessageType_1 = require("./ListMessageType");
+var REQUEST_TYPE = ListMessageType_1.ListMessageType.LIST_REMOVEWITHINDEX;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var ListRemoveWithIndexCodec = /** @class */ (function () {
+    function ListRemoveWithIndexCodec() {
+    }
+    ListRemoveWithIndexCodec.calculateSize = function (name, index) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    ListRemoveWithIndexCodec.encodeRequest = function (name, index) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, index));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(index);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ListRemoveWithIndexCodec.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 ListRemoveWithIndexCodec;
+}());
+exports.ListRemoveWithIndexCodec = ListRemoveWithIndexCodec;

package/lib/codec/ListSetCodec.d.ts

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

package/lib/codec/ListSetCodec.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 ListMessageType_1 = require("./ListMessageType");
+var REQUEST_TYPE = ListMessageType_1.ListMessageType.LIST_SET;
+var RESPONSE_TYPE = 105;
+var RETRYABLE = false;
+var ListSetCodec = /** @class */ (function () {
+    function ListSetCodec() {
+    }
+    ListSetCodec.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;
+    };
+    ListSetCodec.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;
+    };
+    ListSetCodec.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 ListSetCodec;
+}());
+exports.ListSetCodec = ListSetCodec;

package/lib/codec/ListSizeCodec.d.ts

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

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

package/lib/codec/ListSubCodec.d.ts

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

package/lib/codec/ListSubCodec.js

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

package/lib/codec/LockForceUnlockCodec.d.ts

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

package/lib/codec/LockForceUnlockCodec.js

@@ -0,0 +1,47 @@
+"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 LockMessageType_1 = require("./LockMessageType");
+var REQUEST_TYPE = LockMessageType_1.LockMessageType.LOCK_FORCEUNLOCK;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = true;
+var LockForceUnlockCodec = /** @class */ (function () {
+    function LockForceUnlockCodec() {
+    }
+    LockForceUnlockCodec.calculateSize = function (name, referenceId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    LockForceUnlockCodec.encodeRequest = function (name, referenceId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, referenceId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendLong(referenceId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return LockForceUnlockCodec;
+}());
+exports.LockForceUnlockCodec = LockForceUnlockCodec;

package/lib/codec/LockGetLockCountCodec.d.ts

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

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

package/lib/codec/LockGetRemainingLeaseTimeCodec.d.ts

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

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

package/lib/codec/LockIsLockedByCurrentThreadCodec.d.ts

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