@celerispay/hazelcast-client 3.12.5

package/hazelcast-client-default.json

@@ -0,0 +1,56 @@
+{
+    "group": {
+        "name": "dev",
+        "password": "dev-pass"
+    },
+    "properties": {
+        "hazelcast.client.heartbeat.interval": 5000,
+        "hazelcast.client.heartbeat.timeout": 60000,
+        "hazelcast.client.invocation.retry.pause.millis": 1000,
+        "hazelcast.client.invocation.timeout.millis": 120000,
+        "hazelcast.client.cloud.url": "https://coordinator.hazelcast.cloud",
+        "hazelcast.client.statistics.enabled": false,
+        "hazelcast.client.statistics.period.seconds": 3,
+        "hazelcast.invalidation.reconciliation.interval.seconds": 60,
+        "hazelcast.invalidation.max.tolerated.miss.count": 10,
+        "hazelcast.invalidation.min.reconciliation.interval.seconds": 30,
+        "hazelcast.logging.level": 2,
+        "hazelcast.client.autopipelining.enabled": true,
+        "hazelcast.client.autopipelining.threshold.bytes": 8192,
+        "hazelcast.client.socket.no.delay": true
+    },
+    "network": {
+        "clusterMembers": [
+            "127.0.0.1:5701"
+        ],
+        "smartRouting": true,
+        "redoOperation": false,
+        "connectionTimeout": 5000,
+        "connectionAttemptPeriod": 3000,
+        "connectionAttemptLimit": 2,
+        "ssl": {
+            "enabled": false,
+            "sslOptions": null,
+            "factory": null
+        },
+        "hazelcastCloud": {
+            "discoveryToken": null,
+            "enabled": false
+        }
+    },
+    "listeners": [],
+    "serialization": {
+        "defaultNumberType": "double",
+        "isBigEndian": true,
+        "jsonStringDeserializationPolicy": "eager",
+        "stringSerialization": "standard",
+        "dataSerializableFactories": [],
+        "portableFactories": [],
+        "portableVersion": 0,
+        "globalSerializer": {},
+        "serializers": []
+    },
+    "nearCaches": [],
+    "reliableTopics": [],
+    "flakeIdGeneratorConfigs": []
+}

package/hazelcast-client-full.json

@@ -0,0 +1,137 @@
+{
+    "group": {
+        "name": "hazel",
+        "password": "cast"
+    },
+    "properties": {
+        "hazelcast.client.heartbeat.interval": 5000,
+        "hazelcast.client.heartbeat.timeout": 60000,
+        "hazelcast.client.invocation.retry.pause.millis": 1000,
+        "hazelcast.client.invocation.timeout.millis": 120000,
+        "hazelcast.client.cloud.url": "https://coordinator.hazelcast.cloud",
+        "hazelcast.client.statistics.enabled": false,
+        "hazelcast.client.statistics.period.seconds": 3,
+        "hazelcast.invalidation.reconciliation.interval.seconds": 60,
+        "hazelcast.invalidation.max.tolerated.miss.count": 10,
+        "hazelcast.invalidation.min.reconciliation.interval.seconds": 30,
+        "hazelcast.logging.level": 2,
+        "hazelcast.client.autopipelining.enabled": true,
+        "hazelcast.client.autopipelining.threshold.bytes": 8192,
+        "hazelcast.client.socket.no.delay": true
+    },
+    "network": {
+        "clusterMembers": [
+            "127.0.0.1",
+            "127.0.0.2:5702"
+        ],
+        "smartRouting": true,
+        "redoOperation": false,
+        "connectionTimeout": 5000,
+        "connectionAttemptPeriod": 3000,
+        "connectionAttemptLimit": 2,
+        "ssl": {
+            "enabled": false,
+            "sslOptions": null,
+            "factory": {
+                "path": "path/to/file",
+                "exportedName": "exportedName",
+                "properties": {
+                    "userDefinedProperty1": "userDefinedValue"
+                }
+            }
+        },
+        "hazelcastCloud": {
+            "discoveryToken": "EXAMPLE_TOKEN",
+            "enabled": false
+        }
+    },
+    "listeners": [
+        {
+            "type": "lifecycle",
+            "path": "path/to/file",
+            "exportedName": "listener"
+        },
+        {
+            "type": "lifecycle",
+            "path": "path/to/file",
+            "exportedName": "listener2"
+        }
+    ],
+    "serialization": {
+        "defaultNumberType": "double",
+        "isBigEndian": true,
+        "jsonStringDeserializationPolicy": "eager",
+        "stringSerialization": "standard",
+        "dataSerializableFactories": [
+            {
+                "path": "path/to/file",
+                "exportedName": "exportedName",
+                "factoryId": 0
+            }
+        ],
+        "portableFactories": [
+            {
+                "path": "path/to/file",
+                "exportedName": "exportedName",
+                "factoryId": 1
+            }
+        ],
+        "portableVersion": 0,
+        "globalSerializer": {
+            "path": "path/to/file",
+            "exportedName": "exportedName"
+        },
+        "serializers": [
+            {
+                "path": "path/to/custom",
+                "exportedName": "CustomSerializer1",
+                "typeId": 2
+            },
+            {
+                "path": "path/to/custom",
+                "exportedName": "CustomSerializer2",
+                "typeId": 3
+            }
+        ]
+    },
+    "nearCaches": [
+        {
+            "name": "nc-map",
+            "invalidateOnChange": false,
+            "maxIdleSeconds": 2,
+            "inMemoryFormat": "object",
+            "timeToLiveSeconds": 3,
+            "evictionPolicy": "lru",
+            "evictionMaxSize": 3000,
+            "evictionSamplingCount": 4,
+            "evictionSamplingPoolSize": 8
+        }
+    ],
+    "reliableTopics": [
+        {
+            "name": "rt1",
+            "readBatchSize": 35,
+            "overloadPolicy": "discard_newest"
+        },
+        {
+            "name": "rt2",
+            "readBatchSize": 15,
+            "overloadPolicy": "discard_newest"
+        }
+    ],
+    "flakeIdGeneratorConfigs": [
+        {
+            "name": "flakeid",
+            "prefetchCount": 1000,
+            "prefetchValidityMillis": 30000
+        },
+        {
+            "name": "flakeid2",
+            "prefetchCount": 5000,
+            "prefetchValidityMillis": 500000
+        }
+    ],
+    "import": [
+        "hazelcast-client-near-cache.json"
+    ]
+}

package/lib/Address.d.ts

@@ -0,0 +1,17 @@
+import { DataInput, DataOutput } from './serialization/Data';
+import { IdentifiedDataSerializable } from './serialization/Serializable';
+declare class Address implements IdentifiedDataSerializable {
+    host: string;
+    port: number;
+    type: number;
+    private addrStr;
+    constructor(host?: string, port?: number);
+    readData(input: DataInput): any;
+    writeData(output: DataOutput): void;
+    getFactoryId(): number;
+    getClassId(): number;
+    equals(other: Address): boolean;
+    toString(): string;
+    private toStringInternal();
+}
+export = Address;

package/lib/Address.js

@@ -0,0 +1,65 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var net = require("net");
+var ClusterDataFactoryHelper_1 = require("./ClusterDataFactoryHelper");
+var Address = /** @class */ (function () {
+    function Address(host, port) {
+        this.host = host;
+        this.port = port;
+        this.type = net.isIP(host);
+        this.addrStr = this.toStringInternal();
+    }
+    Address.prototype.readData = function (input) {
+        this.port = input.readInt();
+        this.type = input.readByte();
+        this.host = input.readUTF();
+        this.addrStr = this.toStringInternal();
+    };
+    Address.prototype.writeData = function (output) {
+        output.writeInt(this.port);
+        output.writeByte(this.type);
+        output.writeUTF(this.host);
+    };
+    Address.prototype.getFactoryId = function () {
+        return ClusterDataFactoryHelper_1.ClusterDataFactoryHelper.FACTORY_ID;
+    };
+    Address.prototype.getClassId = function () {
+        return ClusterDataFactoryHelper_1.ClusterDataFactoryHelper.ADDRESS_ID;
+    };
+    Address.prototype.equals = function (other) {
+        if (other === this) {
+            return true;
+        }
+        if (other == null) {
+            return false;
+        }
+        if (other.host === this.host &&
+            other.port === this.port &&
+            other.type === this.type) {
+            return true;
+        }
+        return false;
+    };
+    Address.prototype.toString = function () {
+        return this.addrStr;
+    };
+    Address.prototype.toStringInternal = function () {
+        return this.host + ':' + this.port;
+    };
+    return Address;
+}());
+module.exports = Address;

package/lib/BitsUtil.d.ts

@@ -0,0 +1,69 @@
+import { Buffer } from 'safe-buffer';
+import Address = require('./Address');
+import { Data } from './serialization/Data';
+export declare class BitsUtil {
+    static EVENT_MEMBER: number;
+    static EVENT_MEMBERLIST: number;
+    static EVENT_MEMBERATTRIBUTECHANGE: number;
+    static EVENT_ENTRY: number;
+    static EVENT_ITEM: number;
+    static EVENT_TOPIC: number;
+    static EVENT_PARTITIONLOST: number;
+    static EVENT_DISTRIBUTEDOBJECT: number;
+    static EVENT_CACHEINVALIDATION: number;
+    static EVENT_MAPPARTITIONLOST: number;
+    static EVENT_CACHE: number;
+    static EVENT_CACHEBATCHINVALIDATION: number;
+    static EVENT_QUERYCACHESINGLE: number;
+    static EVENT_QUERYCACHEBATCH: number;
+    static EVENT_CACHEPARTITIONLOST: number;
+    static EVENT_IMAPINVALIDATION: number;
+    static EVENT_IMAPBATCHINVALIDATION: number;
+    static EVENT_PARTITIONS: number;
+    static BYTE_SIZE_IN_BYTES: number;
+    static BOOLEAN_SIZE_IN_BYTES: number;
+    static SHORT_SIZE_IN_BYTES: number;
+    static CHAR_SIZE_IN_BYTES: number;
+    static INT_SIZE_IN_BYTES: number;
+    static FLOAT_SIZE_IN_BYTES: number;
+    static LONG_SIZE_IN_BYTES: number;
+    static DOUBLE_SIZE_IN_BYTES: number;
+    static BIG_ENDIAN: number;
+    static LITTLE_ENDIAN: number;
+    static VERSION: number;
+    static BEGIN_FLAG: number;
+    static END_FLAG: number;
+    static BEGIN_END_FLAG: number;
+    static LISTENER_FLAG: number;
+    static NULL_ARRAY_LENGTH: number;
+    static SIZE_OFFSET: number;
+    static FRAME_LENGTH_FIELD_OFFSET: number;
+    static VERSION_FIELD_OFFSET: number;
+    static FLAGS_FIELD_OFFSET: number;
+    static TYPE_FIELD_OFFSET: number;
+    static CORRELATION_ID_FIELD_OFFSET: number;
+    static PARTITION_ID_FIELD_OFFSET: number;
+    static DATA_OFFSET_FIELD_OFFSET: number;
+    static HEADER_SIZE: number;
+    static calculateSizeData(data: Data): number;
+    static getStringSize(value: string, nullable?: boolean): number;
+    static calculateSizeString(value: string): number;
+    static calculateSizeBuffer(value: Buffer): number;
+    static calculateSizeAddress(value: Address): number;
+    static writeUInt32(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeUInt16(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeUInt8(buffer: Buffer, pos: number, val: number): void;
+    static writeInt32(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeInt16(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeInt8(buffer: Buffer, pos: number, val: number): void;
+    static writeFloat(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeDouble(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static readDouble(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readFloat(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readInt8(buffer: Buffer, pos: number): number;
+    static readInt16(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readInt32(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readUInt8(buffer: Buffer, pos: number): number;
+    static readUInt16(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readUInt32(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+}

package/lib/BitsUtil.js

@@ -0,0 +1,202 @@
+"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:no-bitwise */
+var safe_buffer_1 = require("safe-buffer");
+var BitsUtil = /** @class */ (function () {
+    function BitsUtil() {
+    }
+    BitsUtil.calculateSizeData = function (data) {
+        return BitsUtil.INT_SIZE_IN_BYTES + data.totalSize();
+    };
+    BitsUtil.getStringSize = function (value, nullable) {
+        if (nullable === void 0) { nullable = false; }
+        // int32 for string length
+        var size = 4;
+        if (nullable) {
+            size += 1;
+        }
+        size += value == null ? 0 : safe_buffer_1.Buffer.byteLength(value, 'utf8');
+        return size;
+    };
+    BitsUtil.calculateSizeString = function (value) {
+        return this.getStringSize(value);
+    };
+    BitsUtil.calculateSizeBuffer = function (value) {
+        var size = 4;
+        size += value.length;
+        return size;
+    };
+    BitsUtil.calculateSizeAddress = function (value) {
+        var size = 4;
+        size += this.calculateSizeString(value.host);
+        return size;
+    };
+    BitsUtil.writeUInt32 = function (buffer, pos, val, isBigEndian) {
+        if (isBigEndian) {
+            buffer.writeUInt32BE(val, pos);
+        }
+        else {
+            buffer.writeUInt32LE(val, pos);
+        }
+    };
+    BitsUtil.writeUInt16 = function (buffer, pos, val, isBigEndian) {
+        if (isBigEndian) {
+            buffer.writeUInt16BE(val, pos);
+        }
+        else {
+            buffer.writeUInt16LE(val, pos);
+        }
+    };
+    BitsUtil.writeUInt8 = function (buffer, pos, val) {
+        buffer.writeUInt8(val, pos);
+    };
+    BitsUtil.writeInt32 = function (buffer, pos, val, isBigEndian) {
+        if (isBigEndian) {
+            buffer.writeInt32BE(val, pos);
+        }
+        else {
+            buffer.writeInt32LE(val, pos);
+        }
+    };
+    BitsUtil.writeInt16 = function (buffer, pos, val, isBigEndian) {
+        if (isBigEndian) {
+            buffer.writeInt16BE(val, pos);
+        }
+        else {
+            buffer.writeInt16LE(val, pos);
+        }
+    };
+    BitsUtil.writeInt8 = function (buffer, pos, val) {
+        buffer.writeInt8(val, pos);
+    };
+    BitsUtil.writeFloat = function (buffer, pos, val, isBigEndian) {
+        if (isBigEndian) {
+            buffer.writeFloatBE(val, pos);
+        }
+        else {
+            buffer.writeFloatLE(val, pos);
+        }
+    };
+    BitsUtil.writeDouble = function (buffer, pos, val, isBigEndian) {
+        if (isBigEndian) {
+            buffer.writeDoubleBE(val, pos);
+        }
+        else {
+            buffer.writeDoubleLE(val, pos);
+        }
+    };
+    BitsUtil.readDouble = function (buffer, pos, isBigEndian) {
+        if (isBigEndian) {
+            return buffer.readDoubleBE(pos);
+        }
+        else {
+            return buffer.readDoubleLE(pos);
+        }
+    };
+    BitsUtil.readFloat = function (buffer, pos, isBigEndian) {
+        if (isBigEndian) {
+            return buffer.readFloatBE(pos);
+        }
+        else {
+            return buffer.readFloatLE(pos);
+        }
+    };
+    BitsUtil.readInt8 = function (buffer, pos) {
+        return buffer.readInt8(pos);
+    };
+    BitsUtil.readInt16 = function (buffer, pos, isBigEndian) {
+        if (isBigEndian) {
+            return buffer.readInt16BE(pos);
+        }
+        else {
+            return buffer.readInt16LE(pos);
+        }
+    };
+    BitsUtil.readInt32 = function (buffer, pos, isBigEndian) {
+        if (isBigEndian) {
+            return buffer.readInt32BE(pos);
+        }
+        else {
+            return buffer.readInt32LE(pos);
+        }
+    };
+    BitsUtil.readUInt8 = function (buffer, pos) {
+        return buffer.readUInt8(pos);
+    };
+    BitsUtil.readUInt16 = function (buffer, pos, isBigEndian) {
+        if (isBigEndian) {
+            return buffer.readUInt16BE(pos);
+        }
+        else {
+            return buffer.readUInt16LE(pos);
+        }
+    };
+    BitsUtil.readUInt32 = function (buffer, pos, isBigEndian) {
+        if (isBigEndian) {
+            return buffer.readUInt32BE(pos);
+        }
+        else {
+            return buffer.readUInt32LE(pos);
+        }
+    };
+    BitsUtil.EVENT_MEMBER = 200;
+    BitsUtil.EVENT_MEMBERLIST = 201;
+    BitsUtil.EVENT_MEMBERATTRIBUTECHANGE = 202;
+    BitsUtil.EVENT_ENTRY = 203;
+    BitsUtil.EVENT_ITEM = 204;
+    BitsUtil.EVENT_TOPIC = 205;
+    BitsUtil.EVENT_PARTITIONLOST = 206;
+    BitsUtil.EVENT_DISTRIBUTEDOBJECT = 207;
+    BitsUtil.EVENT_CACHEINVALIDATION = 208;
+    BitsUtil.EVENT_MAPPARTITIONLOST = 209;
+    BitsUtil.EVENT_CACHE = 210;
+    BitsUtil.EVENT_CACHEBATCHINVALIDATION = 211;
+    BitsUtil.EVENT_QUERYCACHESINGLE = 212;
+    BitsUtil.EVENT_QUERYCACHEBATCH = 213;
+    BitsUtil.EVENT_CACHEPARTITIONLOST = 214;
+    BitsUtil.EVENT_IMAPINVALIDATION = 215;
+    BitsUtil.EVENT_IMAPBATCHINVALIDATION = 216;
+    BitsUtil.EVENT_PARTITIONS = 217;
+    BitsUtil.BYTE_SIZE_IN_BYTES = 1;
+    BitsUtil.BOOLEAN_SIZE_IN_BYTES = 1;
+    BitsUtil.SHORT_SIZE_IN_BYTES = 2;
+    BitsUtil.CHAR_SIZE_IN_BYTES = 2;
+    BitsUtil.INT_SIZE_IN_BYTES = 4;
+    BitsUtil.FLOAT_SIZE_IN_BYTES = 4;
+    BitsUtil.LONG_SIZE_IN_BYTES = 8;
+    BitsUtil.DOUBLE_SIZE_IN_BYTES = 8;
+    BitsUtil.BIG_ENDIAN = 2;
+    BitsUtil.LITTLE_ENDIAN = 1;
+    BitsUtil.VERSION = 1;
+    BitsUtil.BEGIN_FLAG = 0x80;
+    BitsUtil.END_FLAG = 0x40;
+    BitsUtil.BEGIN_END_FLAG = BitsUtil.BEGIN_FLAG | BitsUtil.END_FLAG;
+    BitsUtil.LISTENER_FLAG = 0x01;
+    BitsUtil.NULL_ARRAY_LENGTH = -1;
+    BitsUtil.SIZE_OFFSET = 0;
+    BitsUtil.FRAME_LENGTH_FIELD_OFFSET = 0;
+    BitsUtil.VERSION_FIELD_OFFSET = BitsUtil.FRAME_LENGTH_FIELD_OFFSET + BitsUtil.INT_SIZE_IN_BYTES;
+    BitsUtil.FLAGS_FIELD_OFFSET = BitsUtil.VERSION_FIELD_OFFSET + BitsUtil.BYTE_SIZE_IN_BYTES;
+    BitsUtil.TYPE_FIELD_OFFSET = BitsUtil.FLAGS_FIELD_OFFSET + BitsUtil.BYTE_SIZE_IN_BYTES;
+    BitsUtil.CORRELATION_ID_FIELD_OFFSET = BitsUtil.TYPE_FIELD_OFFSET + BitsUtil.SHORT_SIZE_IN_BYTES;
+    BitsUtil.PARTITION_ID_FIELD_OFFSET = BitsUtil.CORRELATION_ID_FIELD_OFFSET + BitsUtil.LONG_SIZE_IN_BYTES;
+    BitsUtil.DATA_OFFSET_FIELD_OFFSET = BitsUtil.PARTITION_ID_FIELD_OFFSET + BitsUtil.INT_SIZE_IN_BYTES;
+    BitsUtil.HEADER_SIZE = BitsUtil.DATA_OFFSET_FIELD_OFFSET + BitsUtil.SHORT_SIZE_IN_BYTES;
+    return BitsUtil;
+}());
+exports.BitsUtil = BitsUtil;

package/lib/BuildInfo.d.ts

@@ -0,0 +1,9 @@
+export declare class BuildInfo {
+    static readonly UNKNOWN_VERSION_ID: number;
+    private static readonly MAJOR_VERSION_MULTIPLIER;
+    private static readonly MINOR_VERSION_MULTIPLIER;
+    private static readonly PATTERN;
+    static calculateServerVersionFromString(versionString: string): number;
+    static calculateServerVersion(major: number, minor: number, patch: number): number;
+    static getClientVersion(): string;
+}

package/lib/BuildInfo.js

@@ -0,0 +1,53 @@
+"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 clientVersion = require('../package.json').version;
+var BuildInfo = /** @class */ (function () {
+    function BuildInfo() {
+    }
+    BuildInfo.calculateServerVersionFromString = function (versionString) {
+        if (versionString == null) {
+            return BuildInfo.UNKNOWN_VERSION_ID;
+        }
+        var info = BuildInfo.PATTERN.exec(versionString);
+        if (info == null) {
+            return -1;
+        }
+        var major = Number.parseInt(info[1]);
+        var minor = Number.parseInt(info[2]);
+        var patch;
+        if (info[3] == null) {
+            patch = 0;
+        }
+        else {
+            patch = Number.parseInt(info[3]);
+        }
+        return this.calculateServerVersion(major, minor, patch);
+    };
+    BuildInfo.calculateServerVersion = function (major, minor, patch) {
+        return BuildInfo.MAJOR_VERSION_MULTIPLIER * major + BuildInfo.MINOR_VERSION_MULTIPLIER * minor + patch;
+    };
+    BuildInfo.getClientVersion = function () {
+        return clientVersion;
+    };
+    BuildInfo.UNKNOWN_VERSION_ID = -1;
+    BuildInfo.MAJOR_VERSION_MULTIPLIER = 10000;
+    BuildInfo.MINOR_VERSION_MULTIPLIER = 100;
+    BuildInfo.PATTERN = /^([\d]+)\.([\d]+)(?:\.([\d]+))?(-[\w]+)?(-SNAPSHOT)?(-BETA-.)?$/;
+    return BuildInfo;
+}());
+exports.BuildInfo = BuildInfo;

package/lib/ClientInfo.d.ts

@@ -0,0 +1,15 @@
+import Address = require('./Address');
+export declare class ClientInfo {
+    /**
+     * Unique id of this client instance. It is provided by owner server instance.
+     */
+    uuid: string;
+    /**
+     * Local port address that is used to communicate with cluster.
+     */
+    localAddress: Address;
+    /**
+     * Type of this client. It is always NodeJS.
+     */
+    type: string;
+}

package/lib/ClientInfo.js

@@ -0,0 +1,27 @@
+"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 ClientInfo = /** @class */ (function () {
+    function ClientInfo() {
+        /**
+         * Type of this client. It is always NodeJS.
+         */
+        this.type = 'NodeJS';
+    }
+    return ClientInfo;
+}());
+exports.ClientInfo = ClientInfo;