@celerispay/hazelcast-client 3.12.5

package/lib/codec/RingbufferReadManyCodec.js

@@ -0,0 +1,92 @@
+"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 RingbufferMessageType_1 = require("./RingbufferMessageType");
+var REQUEST_TYPE = RingbufferMessageType_1.RingbufferMessageType.RINGBUFFER_READMANY;
+var RESPONSE_TYPE = 115;
+var RETRYABLE = true;
+var RingbufferReadManyCodec = /** @class */ (function () {
+    function RingbufferReadManyCodec() {
+    }
+    RingbufferReadManyCodec.calculateSize = function (name, startSequence, minCount, maxCount, filter) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        if (filter !== null) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(filter);
+        }
+        return dataSize;
+    };
+    RingbufferReadManyCodec.encodeRequest = function (name, startSequence, minCount, maxCount, filter) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, startSequence, minCount, maxCount, filter));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendLong(startSequence);
+        clientMessage.appendInt32(minCount);
+        clientMessage.appendInt32(maxCount);
+        clientMessage.appendBoolean(filter === null);
+        if (filter !== null) {
+            clientMessage.appendData(filter);
+        }
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    RingbufferReadManyCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'readCount': null,
+            'items': null,
+            'itemSeqs': null
+        };
+        parameters['readCount'] = clientMessage.readInt32();
+        var itemsSize = clientMessage.readInt32();
+        var items = [];
+        for (var itemsIndex = 0; itemsIndex < itemsSize; itemsIndex++) {
+            var itemsItem;
+            itemsItem = clientMessage.readData();
+            items.push(itemsItem);
+        }
+        parameters['items'] = items;
+        if (clientMessage.isComplete()) {
+            return parameters;
+        }
+        if (clientMessage.readBoolean() !== true) {
+            var itemSeqsSize = clientMessage.readInt32();
+            var itemSeqs = [];
+            for (var itemSeqsIndex = 0; itemSeqsIndex < itemSeqsSize; itemSeqsIndex++) {
+                var itemSeqsItem;
+                itemSeqsItem = clientMessage.readLong();
+                itemSeqs.push(itemSeqsItem);
+            }
+            parameters['itemSeqs'] = itemSeqs;
+        }
+        parameters.itemSeqsExist = true;
+        return parameters;
+    };
+    return RingbufferReadManyCodec;
+}());
+exports.RingbufferReadManyCodec = RingbufferReadManyCodec;

package/lib/codec/RingbufferReadOneCodec.d.ts

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

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

package/lib/codec/RingbufferRemainingCapacityCodec.d.ts

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

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

package/lib/codec/RingbufferSizeCodec.d.ts

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

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

package/lib/codec/RingbufferTailSequenceCodec.d.ts

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

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

package/lib/codec/SemaphoreAcquireCodec.d.ts

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

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

package/lib/codec/SemaphoreAvailablePermitsCodec.d.ts

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

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

package/lib/codec/SemaphoreDrainPermitsCodec.d.ts

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

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

package/lib/codec/SemaphoreInitCodec.d.ts

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

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

package/lib/codec/SemaphoreMessageType.d.ts

@@ -0,0 +1,9 @@
+export declare class SemaphoreMessageType {
+    static SEMAPHORE_INIT: number;
+    static SEMAPHORE_ACQUIRE: number;
+    static SEMAPHORE_AVAILABLEPERMITS: number;
+    static SEMAPHORE_DRAINPERMITS: number;
+    static SEMAPHORE_REDUCEPERMITS: number;
+    static SEMAPHORE_RELEASE: number;
+    static SEMAPHORE_TRYACQUIRE: number;
+}

package/lib/codec/SemaphoreMessageType.js

@@ -0,0 +1,31 @@
+"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 SemaphoreMessageType = /** @class */ (function () {
+    function SemaphoreMessageType() {
+    }
+    SemaphoreMessageType.SEMAPHORE_INIT = 0x0d01;
+    SemaphoreMessageType.SEMAPHORE_ACQUIRE = 0x0d02;
+    SemaphoreMessageType.SEMAPHORE_AVAILABLEPERMITS = 0x0d03;
+    SemaphoreMessageType.SEMAPHORE_DRAINPERMITS = 0x0d04;
+    SemaphoreMessageType.SEMAPHORE_REDUCEPERMITS = 0x0d05;
+    SemaphoreMessageType.SEMAPHORE_RELEASE = 0x0d06;
+    SemaphoreMessageType.SEMAPHORE_TRYACQUIRE = 0x0d07;
+    return SemaphoreMessageType;
+}());
+exports.SemaphoreMessageType = SemaphoreMessageType;

package/lib/codec/SemaphoreReducePermitsCodec.d.ts

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