@celerispay/hazelcast-client 3.12.5

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

package/lib/codec/AtomicLongGetAndSetCodec.d.ts

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

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

package/lib/codec/AtomicLongGetCodec.d.ts

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

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

package/lib/codec/AtomicLongIncrementAndGetCodec.d.ts

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

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

package/lib/codec/AtomicLongMessageType.d.ts

@@ -0,0 +1,15 @@
+export declare class AtomicLongMessageType {
+    static ATOMICLONG_APPLY: number;
+    static ATOMICLONG_ALTER: number;
+    static ATOMICLONG_ALTERANDGET: number;
+    static ATOMICLONG_GETANDALTER: number;
+    static ATOMICLONG_ADDANDGET: number;
+    static ATOMICLONG_COMPAREANDSET: number;
+    static ATOMICLONG_DECREMENTANDGET: number;
+    static ATOMICLONG_GET: number;
+    static ATOMICLONG_GETANDADD: number;
+    static ATOMICLONG_GETANDSET: number;
+    static ATOMICLONG_INCREMENTANDGET: number;
+    static ATOMICLONG_GETANDINCREMENT: number;
+    static ATOMICLONG_SET: number;
+}

package/lib/codec/AtomicLongMessageType.js

@@ -0,0 +1,37 @@
+"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 AtomicLongMessageType = /** @class */ (function () {
+    function AtomicLongMessageType() {
+    }
+    AtomicLongMessageType.ATOMICLONG_APPLY = 0x0a01;
+    AtomicLongMessageType.ATOMICLONG_ALTER = 0x0a02;
+    AtomicLongMessageType.ATOMICLONG_ALTERANDGET = 0x0a03;
+    AtomicLongMessageType.ATOMICLONG_GETANDALTER = 0x0a04;
+    AtomicLongMessageType.ATOMICLONG_ADDANDGET = 0x0a05;
+    AtomicLongMessageType.ATOMICLONG_COMPAREANDSET = 0x0a06;
+    AtomicLongMessageType.ATOMICLONG_DECREMENTANDGET = 0x0a07;
+    AtomicLongMessageType.ATOMICLONG_GET = 0x0a08;
+    AtomicLongMessageType.ATOMICLONG_GETANDADD = 0x0a09;
+    AtomicLongMessageType.ATOMICLONG_GETANDSET = 0x0a0a;
+    AtomicLongMessageType.ATOMICLONG_INCREMENTANDGET = 0x0a0b;
+    AtomicLongMessageType.ATOMICLONG_GETANDINCREMENT = 0x0a0c;
+    AtomicLongMessageType.ATOMICLONG_SET = 0x0a0d;
+    return AtomicLongMessageType;
+}());
+exports.AtomicLongMessageType = AtomicLongMessageType;

package/lib/codec/AtomicLongSetCodec.d.ts

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

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

package/lib/codec/ClientAddDistributedObjectListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ClientAddDistributedObjectListenerCodec {
+    static calculateSize(localOnly: boolean): number;
+    static encodeRequest(localOnly: boolean): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+    static handle(clientMessage: ClientMessage, handleEventDistributedobject: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/ClientAddDistributedObjectListenerCodec.js

@@ -0,0 +1,74 @@
+"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 ClientMessageType_1 = require("./ClientMessageType");
+var REQUEST_TYPE = ClientMessageType_1.ClientMessageType.CLIENT_ADDDISTRIBUTEDOBJECTLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var ClientAddDistributedObjectListenerCodec = /** @class */ (function () {
+    function ClientAddDistributedObjectListenerCodec() {
+    }
+    ClientAddDistributedObjectListenerCodec.calculateSize = function (localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    ClientAddDistributedObjectListenerCodec.encodeRequest = function (localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ClientAddDistributedObjectListenerCodec.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;
+    };
+    ClientAddDistributedObjectListenerCodec.handle = function (clientMessage, handleEventDistributedobject, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_DISTRIBUTEDOBJECT && handleEventDistributedobject !== null) {
+            var messageFinished = false;
+            var name = undefined;
+            if (!messageFinished) {
+                name = clientMessage.readString();
+            }
+            var serviceName = undefined;
+            if (!messageFinished) {
+                serviceName = clientMessage.readString();
+            }
+            var eventType = undefined;
+            if (!messageFinished) {
+                eventType = clientMessage.readString();
+            }
+            handleEventDistributedobject(name, serviceName, eventType);
+        }
+    };
+    return ClientAddDistributedObjectListenerCodec;
+}());
+exports.ClientAddDistributedObjectListenerCodec = ClientAddDistributedObjectListenerCodec;

package/lib/codec/ClientAddMembershipListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ClientAddMembershipListenerCodec {
+    static calculateSize(localOnly: boolean): number;
+    static encodeRequest(localOnly: boolean): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+    static handle(clientMessage: ClientMessage, handleEventMember: any, handleEventMemberlist: any, handleEventMemberattributechange: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/ClientAddMembershipListenerCodec.js

@@ -0,0 +1,107 @@
+"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 MemberCodec_1 = require("./MemberCodec");
+var ClientMessageType_1 = require("./ClientMessageType");
+var REQUEST_TYPE = ClientMessageType_1.ClientMessageType.CLIENT_ADDMEMBERSHIPLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var ClientAddMembershipListenerCodec = /** @class */ (function () {
+    function ClientAddMembershipListenerCodec() {
+    }
+    ClientAddMembershipListenerCodec.calculateSize = function (localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    ClientAddMembershipListenerCodec.encodeRequest = function (localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    ClientAddMembershipListenerCodec.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;
+    };
+    ClientAddMembershipListenerCodec.handle = function (clientMessage, handleEventMember, handleEventMemberlist, handleEventMemberattributechange, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_MEMBER && handleEventMember !== null) {
+            var messageFinished = false;
+            var member = undefined;
+            if (!messageFinished) {
+                member = MemberCodec_1.MemberCodec.decode(clientMessage, toObjectFunction);
+            }
+            var eventType = undefined;
+            if (!messageFinished) {
+                eventType = clientMessage.readInt32();
+            }
+            handleEventMember(member, eventType);
+        }
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_MEMBERLIST && handleEventMemberlist !== null) {
+            var messageFinished = false;
+            var members = undefined;
+            if (!messageFinished) {
+                var membersSize = clientMessage.readInt32();
+                members = [];
+                for (var membersIndex = 0; membersIndex < membersSize; membersIndex++) {
+                    var membersItem;
+                    membersItem = MemberCodec_1.MemberCodec.decode(clientMessage, toObjectFunction);
+                    members.push(membersItem);
+                }
+            }
+            handleEventMemberlist(members);
+        }
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_MEMBERATTRIBUTECHANGE && handleEventMemberattributechange !== null) {
+            var messageFinished = false;
+            var uuid = undefined;
+            if (!messageFinished) {
+                uuid = clientMessage.readString();
+            }
+            var key = undefined;
+            if (!messageFinished) {
+                key = clientMessage.readString();
+            }
+            var operationType = undefined;
+            if (!messageFinished) {
+                operationType = clientMessage.readInt32();
+            }
+            var value = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    value = clientMessage.readString();
+                }
+            }
+            handleEventMemberattributechange(uuid, key, operationType, value);
+        }
+    };
+    return ClientAddMembershipListenerCodec;
+}());
+exports.ClientAddMembershipListenerCodec = ClientAddMembershipListenerCodec;

package/lib/codec/ClientAuthenticationCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class ClientAuthenticationCodec {
+    static calculateSize(username: string, password: string, uuid: string, ownerUuid: string, isOwnerConnection: boolean, clientType: string, serializationVersion: any, clientHazelcastVersion: string): number;
+    static encodeRequest(username: string, password: string, uuid: string, ownerUuid: string, isOwnerConnection: boolean, clientType: string, serializationVersion: any, clientHazelcastVersion: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}