@celerispay/hazelcast-client 3.12.5

package/lib/aggregation/AggregatorFactory.d.ts

@@ -0,0 +1,26 @@
+import { IdentifiedDataSerializable, IdentifiedDataSerializableFactory } from '../serialization/Serializable';
+export declare class AggregatorFactory implements IdentifiedDataSerializableFactory {
+    static readonly FACTORY_ID: number;
+    static readonly BIG_DECIMAL_AVG: number;
+    static readonly BIG_DECIMAL_SUM: number;
+    static readonly BIG_INT_AVG: number;
+    static readonly BIG_INT_SUM: number;
+    static readonly COUNT: number;
+    static readonly DISTINCT: number;
+    static readonly DOUBLE_AVG: number;
+    static readonly DOUBLE_SUM: number;
+    static readonly FIXED_SUM: number;
+    static readonly FLOATING_POINT_SUM: number;
+    static readonly INT_AVG: number;
+    static readonly INT_SUM: number;
+    static readonly LONG_AVG: number;
+    static readonly LONG_SUM: number;
+    static readonly MAX: number;
+    static readonly MIN: number;
+    static readonly NUMBER_AVG: number;
+    static readonly MAX_BY: number;
+    static readonly MIN_BY: number;
+    private idToConstructor;
+    constructor();
+    create(type: number): IdentifiedDataSerializable;
+}

package/lib/aggregation/AggregatorFactory.js

@@ -0,0 +1,66 @@
+"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 Aggregator_1 = require("./Aggregator");
+var HazelcastError_1 = require("../HazelcastError");
+var AggregatorFactory = /** @class */ (function () {
+    function AggregatorFactory() {
+        this.idToConstructor = {};
+        this.idToConstructor[AggregatorFactory.COUNT] = Aggregator_1.CountAggregator;
+        this.idToConstructor[AggregatorFactory.DOUBLE_AVG] = Aggregator_1.DoubleAverageAggregator;
+        this.idToConstructor[AggregatorFactory.DOUBLE_SUM] = Aggregator_1.DoubleSumAggregator;
+        this.idToConstructor[AggregatorFactory.FIXED_SUM] = Aggregator_1.FixedPointSumAggregator;
+        this.idToConstructor[AggregatorFactory.FLOATING_POINT_SUM] = Aggregator_1.FloatingPointSumAggregator;
+        this.idToConstructor[AggregatorFactory.INT_AVG] = Aggregator_1.IntegerAverageAggregator;
+        this.idToConstructor[AggregatorFactory.INT_SUM] = Aggregator_1.IntegerSumAggregator;
+        this.idToConstructor[AggregatorFactory.LONG_AVG] = Aggregator_1.LongAverageAggregator;
+        this.idToConstructor[AggregatorFactory.LONG_SUM] = Aggregator_1.LongSumAggregator;
+        this.idToConstructor[AggregatorFactory.MAX] = Aggregator_1.MaxAggregator;
+        this.idToConstructor[AggregatorFactory.MIN] = Aggregator_1.MinAggregator;
+        this.idToConstructor[AggregatorFactory.NUMBER_AVG] = Aggregator_1.NumberAverageAggregator;
+    }
+    AggregatorFactory.prototype.create = function (type) {
+        try {
+            return (new this.idToConstructor[type]());
+        }
+        catch (e) {
+            throw new HazelcastError_1.HazelcastError('There is no known aggregator with type id ' + type, e);
+        }
+    };
+    AggregatorFactory.FACTORY_ID = -41;
+    AggregatorFactory.BIG_DECIMAL_AVG = 0; // not implemented in node.js
+    AggregatorFactory.BIG_DECIMAL_SUM = 1; // not implemented in node.js
+    AggregatorFactory.BIG_INT_AVG = 2; // not implemented in node.js
+    AggregatorFactory.BIG_INT_SUM = 3; // not implemented in node.js
+    AggregatorFactory.COUNT = 4;
+    AggregatorFactory.DISTINCT = 5; // returns java serializable, not usable in node.js
+    AggregatorFactory.DOUBLE_AVG = 6;
+    AggregatorFactory.DOUBLE_SUM = 7;
+    AggregatorFactory.FIXED_SUM = 8;
+    AggregatorFactory.FLOATING_POINT_SUM = 9;
+    AggregatorFactory.INT_AVG = 10;
+    AggregatorFactory.INT_SUM = 11;
+    AggregatorFactory.LONG_AVG = 12;
+    AggregatorFactory.LONG_SUM = 13;
+    AggregatorFactory.MAX = 14;
+    AggregatorFactory.MIN = 15;
+    AggregatorFactory.NUMBER_AVG = 16;
+    AggregatorFactory.MAX_BY = 17; // needs object to implement Java's Comparable interface
+    AggregatorFactory.MIN_BY = 18; // needs object to implement Java's Comparable interface
+    return AggregatorFactory;
+}());
+exports.AggregatorFactory = AggregatorFactory;

package/lib/aggregation/Aggregators.d.ts

@@ -0,0 +1,96 @@
+import { CountAggregator, DoubleAverageAggregator, DoubleSumAggregator, FixedPointSumAggregator, FloatingPointSumAggregator, IntegerAverageAggregator, IntegerSumAggregator, LongAverageAggregator, LongSumAggregator, MaxAggregator, MinAggregator, NumberAverageAggregator } from './Aggregator';
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that counts the input values.
+ * Accepts nulls as input values.
+ * Aggregation result type Long.
+ */
+export declare function count(attributePath?: string): CountAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Double input values (primitive and boxed).
+ * Aggregation result type is number.
+ */
+export declare function doubleAvg(attributePath?: string): DoubleAverageAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Double input values (primitive and boxed).
+ * Aggregation result type is Double.
+ */
+export declare function doubleSum(attributePath?: string): DoubleSumAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts generic Number input values.
+ * Aggregation result type is Double.
+ */
+export declare function numberAvg(attributePath?: string): NumberAverageAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts generic Number input values.
+ * Aggregation result type is {Long}.
+ */
+export declare function fixedPointSum(attributePath?: string): FixedPointSumAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts generic Number input values.
+ * Aggregation result type is number.
+ */
+export declare function floatingPointSum(attributePath?: string): FloatingPointSumAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @param <R> type of the input object.
+ * @return an aggregator that calculates the max of the input values.
+ * Accepts null input values.
+ * Aggregation result type is <R>
+ */
+export declare function max<R>(attributePath?: string): MaxAggregator<R>;
+/**
+ * @param attributePath extracts values from this path if given
+ * @param <R> type of the input object.
+ * @return an aggregator that calculates the min of the input values.
+ * Accepts null input values.
+ * Aggregation result type is <R>
+ */
+export declare function min<R>(attributePath?: string): MinAggregator<R>;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Integer input values (primitive and boxed).
+ * Aggregation result type is number.
+ */
+export declare function integerAvg(attributePath?: string): IntegerAverageAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Integer input values (primitive and boxed).
+ * Aggregation result type is {Long}.
+ */
+export declare function integerSum(attributePath?: string): IntegerSumAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Long input values (primitive and boxed).
+ * Aggregation result type is number.
+ */
+export declare function longAvg(attributePath?: string): LongAverageAggregator;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Long input values (primitive and boxed).
+ * Aggregation result type is {Long}.
+ */
+export declare function longSum(attributePath?: string): LongSumAggregator;

package/lib/aggregation/Aggregators.js

@@ -0,0 +1,149 @@
+"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 Aggregator_1 = require("./Aggregator");
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that counts the input values.
+ * Accepts nulls as input values.
+ * Aggregation result type Long.
+ */
+function count(attributePath) {
+    return new Aggregator_1.CountAggregator(attributePath);
+}
+exports.count = count;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Double input values (primitive and boxed).
+ * Aggregation result type is number.
+ */
+function doubleAvg(attributePath) {
+    return new Aggregator_1.DoubleAverageAggregator(attributePath);
+}
+exports.doubleAvg = doubleAvg;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Double input values (primitive and boxed).
+ * Aggregation result type is Double.
+ */
+function doubleSum(attributePath) {
+    return new Aggregator_1.DoubleSumAggregator(attributePath);
+}
+exports.doubleSum = doubleSum;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts generic Number input values.
+ * Aggregation result type is Double.
+ */
+function numberAvg(attributePath) {
+    return new Aggregator_1.NumberAverageAggregator(attributePath);
+}
+exports.numberAvg = numberAvg;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts generic Number input values.
+ * Aggregation result type is {Long}.
+ */
+function fixedPointSum(attributePath) {
+    return new Aggregator_1.FixedPointSumAggregator(attributePath);
+}
+exports.fixedPointSum = fixedPointSum;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts generic Number input values.
+ * Aggregation result type is number.
+ */
+function floatingPointSum(attributePath) {
+    return new Aggregator_1.FloatingPointSumAggregator(attributePath);
+}
+exports.floatingPointSum = floatingPointSum;
+/**
+ * @param attributePath extracts values from this path if given
+ * @param <R> type of the input object.
+ * @return an aggregator that calculates the max of the input values.
+ * Accepts null input values.
+ * Aggregation result type is <R>
+ */
+function max(attributePath) {
+    return new Aggregator_1.MaxAggregator(attributePath);
+}
+exports.max = max;
+/**
+ * @param attributePath extracts values from this path if given
+ * @param <R> type of the input object.
+ * @return an aggregator that calculates the min of the input values.
+ * Accepts null input values.
+ * Aggregation result type is <R>
+ */
+function min(attributePath) {
+    return new Aggregator_1.MinAggregator(attributePath);
+}
+exports.min = min;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Integer input values (primitive and boxed).
+ * Aggregation result type is number.
+ */
+function integerAvg(attributePath) {
+    return new Aggregator_1.IntegerAverageAggregator(attributePath);
+}
+exports.integerAvg = integerAvg;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Integer input values (primitive and boxed).
+ * Aggregation result type is {Long}.
+ */
+function integerSum(attributePath) {
+    return new Aggregator_1.IntegerSumAggregator(attributePath);
+}
+exports.integerSum = integerSum;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the average of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Long input values (primitive and boxed).
+ * Aggregation result type is number.
+ */
+function longAvg(attributePath) {
+    return new Aggregator_1.LongAverageAggregator(attributePath);
+}
+exports.longAvg = longAvg;
+/**
+ * @param attributePath extracts values from this path if given
+ * @return an aggregator that calculates the sum of the input values.
+ * Does NOT accept null input values.
+ * Accepts only Long input values (primitive and boxed).
+ * Aggregation result type is {Long}.
+ */
+function longSum(attributePath) {
+    return new Aggregator_1.LongSumAggregator(attributePath);
+}
+exports.longSum = longSum;

package/lib/codec/AddressCodec.d.ts

@@ -0,0 +1,6 @@
+import ClientMessage = require('../ClientMessage');
+import Address = require('../Address');
+export declare class AddressCodec {
+    static encode(clientMessage: ClientMessage, target: Address): void;
+    static decode(clientMessage: ClientMessage, toObjectFunction: Function): Address;
+}

package/lib/codec/AddressCodec.js

@@ -0,0 +1,33 @@
+"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 Address = require("../Address");
+var AddressCodec = /** @class */ (function () {
+    function AddressCodec() {
+    }
+    AddressCodec.encode = function (clientMessage, target) {
+        clientMessage.appendString(target.host);
+        clientMessage.appendInt32(target.port);
+    };
+    AddressCodec.decode = function (clientMessage, toObjectFunction) {
+        var host = clientMessage.readString();
+        var port = clientMessage.readInt32();
+        return new Address(host, port);
+    };
+    return AddressCodec;
+}());
+exports.AddressCodec = AddressCodec;

package/lib/codec/AtomicLongAddAndGetCodec.d.ts

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

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

package/lib/codec/AtomicLongCompareAndSetCodec.d.ts

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

package/lib/codec/AtomicLongCompareAndSetCodec.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 AtomicLongMessageType_1 = require("./AtomicLongMessageType");
+var REQUEST_TYPE = AtomicLongMessageType_1.AtomicLongMessageType.ATOMICLONG_COMPAREANDSET;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var AtomicLongCompareAndSetCodec = /** @class */ (function () {
+    function AtomicLongCompareAndSetCodec() {
+    }
+    AtomicLongCompareAndSetCodec.calculateSize = function (name, expected, updated) {
+        // 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.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    AtomicLongCompareAndSetCodec.encodeRequest = function (name, expected, updated) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, expected, updated));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendLong(expected);
+        clientMessage.appendLong(updated);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    AtomicLongCompareAndSetCodec.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 AtomicLongCompareAndSetCodec;
+}());
+exports.AtomicLongCompareAndSetCodec = AtomicLongCompareAndSetCodec;

package/lib/codec/AtomicLongDecrementAndGetCodec.d.ts

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

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

package/lib/codec/AtomicLongGetAndAddCodec.d.ts

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

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

package/lib/codec/AtomicLongGetAndIncrementCodec.d.ts

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