@celerispay/hazelcast-client 3.12.5

package/lib/HazelcastError.js

@@ -0,0 +1,389 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var HazelcastError = /** @class */ (function (_super) {
+    __extends(HazelcastError, _super);
+    function HazelcastError(msg, cause) {
+        var _this = _super.call(this, msg) || this;
+        _this.cause = cause;
+        Error.captureStackTrace(_this, HazelcastError);
+        Object.setPrototypeOf(_this, HazelcastError.prototype);
+        return _this;
+    }
+    return HazelcastError;
+}(Error));
+exports.HazelcastError = HazelcastError;
+var HazelcastSerializationError = /** @class */ (function (_super) {
+    __extends(HazelcastSerializationError, _super);
+    function HazelcastSerializationError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, HazelcastSerializationError.prototype);
+        return _this;
+    }
+    return HazelcastSerializationError;
+}(HazelcastError));
+exports.HazelcastSerializationError = HazelcastSerializationError;
+var AuthenticationError = /** @class */ (function (_super) {
+    __extends(AuthenticationError, _super);
+    function AuthenticationError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, AuthenticationError.prototype);
+        return _this;
+    }
+    return AuthenticationError;
+}(HazelcastError));
+exports.AuthenticationError = AuthenticationError;
+var ClientNotActiveError = /** @class */ (function (_super) {
+    __extends(ClientNotActiveError, _super);
+    function ClientNotActiveError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ClientNotActiveError.prototype);
+        return _this;
+    }
+    return ClientNotActiveError;
+}(HazelcastError));
+exports.ClientNotActiveError = ClientNotActiveError;
+var IllegalStateError = /** @class */ (function (_super) {
+    __extends(IllegalStateError, _super);
+    function IllegalStateError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, IllegalStateError.prototype);
+        return _this;
+    }
+    return IllegalStateError;
+}(HazelcastError));
+exports.IllegalStateError = IllegalStateError;
+var StaleSequenceError = /** @class */ (function (_super) {
+    __extends(StaleSequenceError, _super);
+    function StaleSequenceError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, StaleSequenceError.prototype);
+        return _this;
+    }
+    return StaleSequenceError;
+}(HazelcastError));
+exports.StaleSequenceError = StaleSequenceError;
+var TopicOverloadError = /** @class */ (function (_super) {
+    __extends(TopicOverloadError, _super);
+    function TopicOverloadError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, TopicOverloadError.prototype);
+        return _this;
+    }
+    return TopicOverloadError;
+}(HazelcastError));
+exports.TopicOverloadError = TopicOverloadError;
+var IOError = /** @class */ (function (_super) {
+    __extends(IOError, _super);
+    function IOError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, IOError.prototype);
+        return _this;
+    }
+    return IOError;
+}(HazelcastError));
+exports.IOError = IOError;
+var UndefinedErrorCodeError = /** @class */ (function (_super) {
+    __extends(UndefinedErrorCodeError, _super);
+    function UndefinedErrorCodeError(msg, className) {
+        var _this = _super.call(this, 'Class name: ' + className + ' , Message: ' + msg) || this;
+        Object.setPrototypeOf(_this, UndefinedErrorCodeError.prototype);
+        return _this;
+    }
+    return UndefinedErrorCodeError;
+}(HazelcastError));
+exports.UndefinedErrorCodeError = UndefinedErrorCodeError;
+var InvocationTimeoutError = /** @class */ (function (_super) {
+    __extends(InvocationTimeoutError, _super);
+    function InvocationTimeoutError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, InvocationTimeoutError.prototype);
+        return _this;
+    }
+    return InvocationTimeoutError;
+}(HazelcastError));
+exports.InvocationTimeoutError = InvocationTimeoutError;
+var RetryableHazelcastError = /** @class */ (function (_super) {
+    __extends(RetryableHazelcastError, _super);
+    function RetryableHazelcastError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, RetryableHazelcastError.prototype);
+        return _this;
+    }
+    return RetryableHazelcastError;
+}(HazelcastError));
+exports.RetryableHazelcastError = RetryableHazelcastError;
+var TargetNotMemberError = /** @class */ (function (_super) {
+    __extends(TargetNotMemberError, _super);
+    function TargetNotMemberError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, TargetNotMemberError.prototype);
+        return _this;
+    }
+    return TargetNotMemberError;
+}(RetryableHazelcastError));
+exports.TargetNotMemberError = TargetNotMemberError;
+var CallerNotMemberError = /** @class */ (function (_super) {
+    __extends(CallerNotMemberError, _super);
+    function CallerNotMemberError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, CallerNotMemberError.prototype);
+        return _this;
+    }
+    return CallerNotMemberError;
+}(RetryableHazelcastError));
+exports.CallerNotMemberError = CallerNotMemberError;
+var CancellationError = /** @class */ (function (_super) {
+    __extends(CancellationError, _super);
+    function CancellationError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, CancellationError.prototype);
+        return _this;
+    }
+    return CancellationError;
+}(IllegalStateError));
+exports.CancellationError = CancellationError;
+var ClassCastError = /** @class */ (function (_super) {
+    __extends(ClassCastError, _super);
+    function ClassCastError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ClassCastError.prototype);
+        return _this;
+    }
+    return ClassCastError;
+}(HazelcastError));
+exports.ClassCastError = ClassCastError;
+var ClassNotFoundError = /** @class */ (function (_super) {
+    __extends(ClassNotFoundError, _super);
+    function ClassNotFoundError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ClassNotFoundError.prototype);
+        return _this;
+    }
+    return ClassNotFoundError;
+}(HazelcastError));
+exports.ClassNotFoundError = ClassNotFoundError;
+var ConcurrentModificationError = /** @class */ (function (_super) {
+    __extends(ConcurrentModificationError, _super);
+    function ConcurrentModificationError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ConcurrentModificationError.prototype);
+        return _this;
+    }
+    return ConcurrentModificationError;
+}(HazelcastError));
+exports.ConcurrentModificationError = ConcurrentModificationError;
+var ConfigMismatchError = /** @class */ (function (_super) {
+    __extends(ConfigMismatchError, _super);
+    function ConfigMismatchError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ConfigMismatchError.prototype);
+        return _this;
+    }
+    return ConfigMismatchError;
+}(HazelcastError));
+exports.ConfigMismatchError = ConfigMismatchError;
+var ConfigurationError = /** @class */ (function (_super) {
+    __extends(ConfigurationError, _super);
+    function ConfigurationError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ConfigurationError.prototype);
+        return _this;
+    }
+    return ConfigurationError;
+}(HazelcastError));
+exports.ConfigurationError = ConfigurationError;
+var DistributedObjectDestroyedError = /** @class */ (function (_super) {
+    __extends(DistributedObjectDestroyedError, _super);
+    function DistributedObjectDestroyedError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, DistributedObjectDestroyedError.prototype);
+        return _this;
+    }
+    return DistributedObjectDestroyedError;
+}(HazelcastError));
+exports.DistributedObjectDestroyedError = DistributedObjectDestroyedError;
+var DuplicateInstanceNameError = /** @class */ (function (_super) {
+    __extends(DuplicateInstanceNameError, _super);
+    function DuplicateInstanceNameError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, DuplicateInstanceNameError.prototype);
+        return _this;
+    }
+    return DuplicateInstanceNameError;
+}(HazelcastError));
+exports.DuplicateInstanceNameError = DuplicateInstanceNameError;
+var HazelcastInstanceNotActiveError = /** @class */ (function (_super) {
+    __extends(HazelcastInstanceNotActiveError, _super);
+    function HazelcastInstanceNotActiveError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, HazelcastInstanceNotActiveError.prototype);
+        return _this;
+    }
+    return HazelcastInstanceNotActiveError;
+}(IllegalStateError));
+exports.HazelcastInstanceNotActiveError = HazelcastInstanceNotActiveError;
+var MemberLeftError = /** @class */ (function (_super) {
+    __extends(MemberLeftError, _super);
+    function MemberLeftError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, MemberLeftError.prototype);
+        return _this;
+    }
+    return MemberLeftError;
+}(RetryableHazelcastError));
+exports.MemberLeftError = MemberLeftError;
+var PartitionMigratingError = /** @class */ (function (_super) {
+    __extends(PartitionMigratingError, _super);
+    function PartitionMigratingError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, PartitionMigratingError.prototype);
+        return _this;
+    }
+    return PartitionMigratingError;
+}(RetryableHazelcastError));
+exports.PartitionMigratingError = PartitionMigratingError;
+var QueryError = /** @class */ (function (_super) {
+    __extends(QueryError, _super);
+    function QueryError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, QueryError.prototype);
+        return _this;
+    }
+    return QueryError;
+}(HazelcastError));
+exports.QueryError = QueryError;
+var TransactionError = /** @class */ (function (_super) {
+    __extends(TransactionError, _super);
+    function TransactionError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, TransactionError.prototype);
+        return _this;
+    }
+    return TransactionError;
+}(HazelcastError));
+exports.TransactionError = TransactionError;
+var TransactionNotActiveError = /** @class */ (function (_super) {
+    __extends(TransactionNotActiveError, _super);
+    function TransactionNotActiveError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, TransactionNotActiveError.prototype);
+        return _this;
+    }
+    return TransactionNotActiveError;
+}(HazelcastError));
+exports.TransactionNotActiveError = TransactionNotActiveError;
+var TransactionTimedOutError = /** @class */ (function (_super) {
+    __extends(TransactionTimedOutError, _super);
+    function TransactionTimedOutError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, TransactionTimedOutError.prototype);
+        return _this;
+    }
+    return TransactionTimedOutError;
+}(HazelcastError));
+exports.TransactionTimedOutError = TransactionTimedOutError;
+var QuorumError = /** @class */ (function (_super) {
+    __extends(QuorumError, _super);
+    function QuorumError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, QuorumError.prototype);
+        return _this;
+    }
+    return QuorumError;
+}(TransactionError));
+exports.QuorumError = QuorumError;
+var RetryableIOError = /** @class */ (function (_super) {
+    __extends(RetryableIOError, _super);
+    function RetryableIOError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, RetryableIOError.prototype);
+        return _this;
+    }
+    return RetryableIOError;
+}(RetryableHazelcastError));
+exports.RetryableIOError = RetryableIOError;
+var TargetDisconnectedError = /** @class */ (function (_super) {
+    __extends(TargetDisconnectedError, _super);
+    function TargetDisconnectedError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, TargetDisconnectedError.prototype);
+        return _this;
+    }
+    return TargetDisconnectedError;
+}(HazelcastError));
+exports.TargetDisconnectedError = TargetDisconnectedError;
+var UnsupportedOperationError = /** @class */ (function (_super) {
+    __extends(UnsupportedOperationError, _super);
+    function UnsupportedOperationError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, UnsupportedOperationError.prototype);
+        return _this;
+    }
+    return UnsupportedOperationError;
+}(HazelcastError));
+exports.UnsupportedOperationError = UnsupportedOperationError;
+var ConsistencyLostError = /** @class */ (function (_super) {
+    __extends(ConsistencyLostError, _super);
+    function ConsistencyLostError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, ConsistencyLostError.prototype);
+        return _this;
+    }
+    return ConsistencyLostError;
+}(HazelcastError));
+exports.ConsistencyLostError = ConsistencyLostError;
+var NoDataMemberInClusterError = /** @class */ (function (_super) {
+    __extends(NoDataMemberInClusterError, _super);
+    function NoDataMemberInClusterError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, NoDataMemberInClusterError.prototype);
+        return _this;
+    }
+    return NoDataMemberInClusterError;
+}(HazelcastError));
+exports.NoDataMemberInClusterError = NoDataMemberInClusterError;
+var StaleTaskIdError = /** @class */ (function (_super) {
+    __extends(StaleTaskIdError, _super);
+    function StaleTaskIdError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, StaleTaskIdError.prototype);
+        return _this;
+    }
+    return StaleTaskIdError;
+}(HazelcastError));
+exports.StaleTaskIdError = StaleTaskIdError;
+var NodeIdOutOfRangeError = /** @class */ (function (_super) {
+    __extends(NodeIdOutOfRangeError, _super);
+    function NodeIdOutOfRangeError(msg, cause) {
+        var _this = _super.call(this, msg, cause) || this;
+        Object.setPrototypeOf(_this, NodeIdOutOfRangeError.prototype);
+        return _this;
+    }
+    return NodeIdOutOfRangeError;
+}(HazelcastError));
+exports.NodeIdOutOfRangeError = NodeIdOutOfRangeError;

package/lib/HeartbeatService.d.ts

@@ -0,0 +1,30 @@
+import { ConnectionHeartbeatListener } from './core/ConnectionHeartbeatListener';
+import HazelcastClient from './HazelcastClient';
+/**
+ * Hearbeat Service
+ */
+export declare class Heartbeat {
+    private client;
+    private heartbeatTimeout;
+    private heartbeatInterval;
+    private listeners;
+    private logger;
+    private timer;
+    constructor(client: HazelcastClient);
+    /**
+     * Starts sending periodic heartbeat operations.
+     */
+    start(): void;
+    /**
+     * Cancels scheduled heartbeat operations.
+     */
+    cancel(): void;
+    /**
+     * Registers a heartbeat listener. Listener is invoked when a heartbeat related event occurs.
+     * @param heartbeatListener
+     */
+    addListener(heartbeatListener: ConnectionHeartbeatListener): void;
+    private heartbeatFunction();
+    private onHeartbeatStopped(connection);
+    private onHeartbeatRestored(connection);
+}

package/lib/HeartbeatService.js

@@ -0,0 +1,108 @@
+"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 ClientPingCodec_1 = require("./codec/ClientPingCodec");
+var PROPERTY_HEARTBEAT_INTERVAL = 'hazelcast.client.heartbeat.interval';
+var PROPERTY_HEARTBEAT_TIMEOUT = 'hazelcast.client.heartbeat.timeout';
+/**
+ * Hearbeat Service
+ */
+var Heartbeat = /** @class */ (function () {
+    function Heartbeat(client) {
+        this.listeners = [];
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        this.heartbeatInterval = this.client.getConfig().properties[PROPERTY_HEARTBEAT_INTERVAL];
+        this.heartbeatTimeout = this.client.getConfig().properties[PROPERTY_HEARTBEAT_TIMEOUT];
+    }
+    /**
+     * Starts sending periodic heartbeat operations.
+     */
+    Heartbeat.prototype.start = function () {
+        this.timer = setTimeout(this.heartbeatFunction.bind(this), this.heartbeatInterval);
+    };
+    /**
+     * Cancels scheduled heartbeat operations.
+     */
+    Heartbeat.prototype.cancel = function () {
+        clearTimeout(this.timer);
+    };
+    /**
+     * Registers a heartbeat listener. Listener is invoked when a heartbeat related event occurs.
+     * @param heartbeatListener
+     */
+    Heartbeat.prototype.addListener = function (heartbeatListener) {
+        this.listeners.push(heartbeatListener);
+    };
+    Heartbeat.prototype.heartbeatFunction = function () {
+        var _this = this;
+        var estConnections = this.client.getConnectionManager().establishedConnections;
+        var _loop_1 = function (address) {
+            if (estConnections[address]) {
+                var conn_1 = estConnections[address];
+                var now = Date.now();
+                if (now - conn_1.getLastReadTimeMillis() > this_1.heartbeatTimeout) {
+                    if (conn_1.isHeartbeating()) {
+                        conn_1.setHeartbeating(false);
+                        this_1.onHeartbeatStopped(conn_1);
+                    }
+                }
+                if (now - conn_1.getLastWriteTimeMillis() > this_1.heartbeatInterval) {
+                    var req = ClientPingCodec_1.ClientPingCodec.encodeRequest();
+                    this_1.client.getInvocationService().invokeOnConnection(conn_1, req)
+                        .catch(function (error) {
+                        if (conn_1.isAlive()) {
+                            _this.logger.warn('HeartbeatService', 'Error receiving ping answer from the connection: '
+                                + conn_1 + ' ' + error);
+                        }
+                    });
+                }
+                else {
+                    if (!conn_1.isHeartbeating()) {
+                        conn_1.setHeartbeating(true);
+                        this_1.onHeartbeatRestored(conn_1);
+                    }
+                }
+            }
+        };
+        var this_1 = this;
+        for (var address in estConnections) {
+            _loop_1(address);
+        }
+        this.timer = setTimeout(this.heartbeatFunction.bind(this), this.heartbeatInterval);
+    };
+    Heartbeat.prototype.onHeartbeatStopped = function (connection) {
+        var _this = this;
+        this.logger.warn('HeartbeatService', 'Heartbeat stopped on ' + connection.toString());
+        this.listeners.forEach(function (listener) {
+            if (listener.hasOwnProperty('onHeartbeatStopped')) {
+                setImmediate(listener.onHeartbeatStopped.bind(_this), connection);
+            }
+        });
+    };
+    Heartbeat.prototype.onHeartbeatRestored = function (connection) {
+        var _this = this;
+        this.logger.warn('HeartbeatService', 'Heartbeat restored on ' + connection.toString());
+        this.listeners.forEach(function (listener) {
+            if (listener.hasOwnProperty('onHeartbeatRestored')) {
+                setImmediate(listener.onHeartbeatRestored.bind(_this), connection);
+            }
+        });
+    };
+    return Heartbeat;
+}());
+exports.Heartbeat = Heartbeat;

package/lib/LifecycleService.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import HazelcastClient from './HazelcastClient';
+/**
+ * Lifecycle events.
+ */
+export declare let LifecycleEvent: {
+    name: string;
+    starting: string;
+    started: string;
+    shuttingDown: string;
+    shutdown: string;
+};
+/**
+ * LifecycleService
+ */
+export declare class LifecycleService extends EventEmitter {
+    private active;
+    private client;
+    private logger;
+    constructor(client: HazelcastClient);
+    /**
+     * Causes LifecycleService to emit given event to all registered listeners.
+     * @param state
+     */
+    emitLifecycleEvent(state: string): void;
+    /**
+     * Returns the active state of the client.
+     * @returns {boolean}
+     */
+    isRunning(): boolean;
+}

package/lib/LifecycleService.js

@@ -0,0 +1,105 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var events_1 = require("events");
+var Util = require("./Util");
+/**
+ * Lifecycle events.
+ */
+exports.LifecycleEvent = {
+    /**
+     * events are emitted with this name.
+     */
+    name: 'lifecycleEvent',
+    /**
+     * From creation of client to connected state.
+     */
+    starting: 'starting',
+    /**
+     * Client is connected to cluster. Ready to use.
+     */
+    started: 'started',
+    /**
+     * Disconnect initiated.
+     */
+    shuttingDown: 'shuttingDown',
+    /**
+     * Disconnect completed gracefully.
+     */
+    shutdown: 'shutdown',
+};
+/**
+ * LifecycleService
+ */
+var LifecycleService = /** @class */ (function (_super) {
+    __extends(LifecycleService, _super);
+    function LifecycleService(client) {
+        var _this = _super.call(this) || this;
+        _this.setMaxListeners(0);
+        _this.client = client;
+        _this.logger = _this.client.getLoggingService().getLogger();
+        var listeners = client.getConfig().listeners.lifecycle;
+        listeners.forEach(function (listener) {
+            _this.on(exports.LifecycleEvent.name, listener);
+        });
+        var listenerConfigs = client.getConfig().listenerConfigs;
+        listenerConfigs.forEach(function (importConfig) {
+            var path = importConfig.path;
+            var exportedName = importConfig.exportedName;
+            var listener = Util.loadNameFromPath(path, exportedName);
+            _this.on(exports.LifecycleEvent.name, listener);
+        });
+        _this.emitLifecycleEvent(exports.LifecycleEvent.starting);
+        return _this;
+    }
+    /**
+     * Causes LifecycleService to emit given event to all registered listeners.
+     * @param state
+     */
+    LifecycleService.prototype.emitLifecycleEvent = function (state) {
+        if (!exports.LifecycleEvent.hasOwnProperty(state)) {
+            throw new Error(state + ' is not a valid lifecycle event');
+        }
+        if (state === exports.LifecycleEvent.started) {
+            this.active = true;
+        }
+        else if (state === exports.LifecycleEvent.shuttingDown) {
+            this.active = false;
+        }
+        this.logger.info('LifecycleService', 'HazelcastClient is ' + state);
+        this.emit(exports.LifecycleEvent.name, state);
+    };
+    /**
+     * Returns the active state of the client.
+     * @returns {boolean}
+     */
+    LifecycleService.prototype.isRunning = function () {
+        return this.active;
+    };
+    return LifecycleService;
+}(events_1.EventEmitter));
+exports.LifecycleService = LifecycleService;

package/lib/ListenerMessageCodec.d.ts

@@ -0,0 +1,6 @@
+import ClientMessage = require('./ClientMessage');
+export interface ListenerMessageCodec {
+    encodeAddRequest: (localOnly: boolean) => ClientMessage;
+    decodeAddResponse: (msg: ClientMessage) => string;
+    encodeRemoveRequest: (listenerId: string) => ClientMessage;
+}

package/lib/ListenerMessageCodec.js

@@ -0,0 +1,17 @@
+"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 });