@celerispay/hazelcast-client 3.12.5

package/lib/core/Predicate.js

@@ -0,0 +1,113 @@
+"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 DefaultPredicates_1 = require("../serialization/DefaultPredicates");
+function sql(str) {
+    return new DefaultPredicates_1.SqlPredicate(str);
+}
+exports.sql = sql;
+function and() {
+    var predicates = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        predicates[_i] = arguments[_i];
+    }
+    return new (DefaultPredicates_1.AndPredicate.bind.apply(DefaultPredicates_1.AndPredicate, [void 0].concat(predicates)))();
+}
+exports.and = and;
+function between(field, from, to) {
+    return new DefaultPredicates_1.BetweenPredicate(field, from, to);
+}
+exports.between = between;
+function equal(field, value) {
+    return new DefaultPredicates_1.EqualPredicate(field, value);
+}
+exports.equal = equal;
+function greaterThan(field, value) {
+    return new DefaultPredicates_1.GreaterLessPredicate(field, value, false, false);
+}
+exports.greaterThan = greaterThan;
+function greaterEqual(field, value) {
+    return new DefaultPredicates_1.GreaterLessPredicate(field, value, true, false);
+}
+exports.greaterEqual = greaterEqual;
+function lessThan(field, value) {
+    return new DefaultPredicates_1.GreaterLessPredicate(field, value, false, true);
+}
+exports.lessThan = lessThan;
+function lessEqual(field, value) {
+    return new DefaultPredicates_1.GreaterLessPredicate(field, value, true, true);
+}
+exports.lessEqual = lessEqual;
+function like(field, expr) {
+    return new DefaultPredicates_1.LikePredicate(field, expr);
+}
+exports.like = like;
+function ilike(field, expr) {
+    return new DefaultPredicates_1.ILikePredicate(field, expr);
+}
+exports.ilike = ilike;
+function inPredicate(field) {
+    var values = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        values[_i - 1] = arguments[_i];
+    }
+    return new (DefaultPredicates_1.InPredicate.bind.apply(DefaultPredicates_1.InPredicate, [void 0, field].concat(values)))();
+}
+exports.inPredicate = inPredicate;
+function instanceOf(className) {
+    return new DefaultPredicates_1.InstanceOfPredicate(className);
+}
+exports.instanceOf = instanceOf;
+function notEqual(field, value) {
+    return new DefaultPredicates_1.NotEqualPredicate(field, value);
+}
+exports.notEqual = notEqual;
+function not(predic) {
+    return new DefaultPredicates_1.NotPredicate(predic);
+}
+exports.not = not;
+function or() {
+    var predicates = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        predicates[_i] = arguments[_i];
+    }
+    return new (DefaultPredicates_1.OrPredicate.bind.apply(DefaultPredicates_1.OrPredicate, [void 0].concat(predicates)))();
+}
+exports.or = or;
+function regex(field, reg) {
+    return new DefaultPredicates_1.RegexPredicate(field, reg);
+}
+exports.regex = regex;
+function alwaysTrue() {
+    return DefaultPredicates_1.TruePredicate.INSTANCE;
+}
+exports.alwaysTrue = alwaysTrue;
+function alwaysFalse() {
+    return DefaultPredicates_1.FalsePredicate.INSTANCE;
+}
+exports.alwaysFalse = alwaysFalse;
+function paging(predicate, pageSize, comparator) {
+    if (comparator === void 0) { comparator = null; }
+    return new DefaultPredicates_1.PagingPredicate(predicate, pageSize, comparator);
+}
+exports.paging = paging;
+var IterationType;
+(function (IterationType) {
+    IterationType[IterationType["KEY"] = 0] = "KEY";
+    IterationType[IterationType["VALUE"] = 1] = "VALUE";
+    IterationType[IterationType["ENTRY"] = 2] = "ENTRY";
+})(IterationType = exports.IterationType || (exports.IterationType = {}));

package/lib/core/ReadOnlyLazyList.d.ts

@@ -0,0 +1,12 @@
+import { SerializationService } from '../serialization/SerializationService';
+export declare class ReadOnlyLazyList<T> implements Iterable<T> {
+    private internalArray;
+    private serializationService;
+    constructor(array: any[], serializationService: SerializationService);
+    get(index: number): T;
+    size(): number;
+    values(): Iterator<T>;
+    slice(start: number, end?: number): ReadOnlyLazyList<T>;
+    toArray(): T[];
+    [Symbol.iterator](): Iterator<T>;
+}

package/lib/core/ReadOnlyLazyList.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 });
+var ReadOnlyLazyListIterator = /** @class */ (function () {
+    function ReadOnlyLazyListIterator(list) {
+        this.index = 0;
+        this.list = list;
+    }
+    ReadOnlyLazyListIterator.prototype.next = function () {
+        if (this.index < this.list.size()) {
+            return { done: false, value: this.list.get(this.index++) };
+        }
+        else {
+            return { done: true, value: undefined };
+        }
+    };
+    return ReadOnlyLazyListIterator;
+}());
+var ReadOnlyLazyList = /** @class */ (function () {
+    function ReadOnlyLazyList(array, serializationService) {
+        this.internalArray = array;
+        this.serializationService = serializationService;
+    }
+    ReadOnlyLazyList.prototype.get = function (index) {
+        var dataOrObject = this.internalArray[index];
+        if (dataOrObject == null) {
+            return undefined;
+        }
+        if (this.serializationService.isData(dataOrObject)) {
+            var obj = this.serializationService.toObject(dataOrObject);
+            this.internalArray[index] = obj;
+            return obj;
+        }
+        else {
+            return dataOrObject;
+        }
+    };
+    ReadOnlyLazyList.prototype.size = function () {
+        return this.internalArray.length;
+    };
+    ReadOnlyLazyList.prototype.values = function () {
+        return new ReadOnlyLazyListIterator(this);
+    };
+    ReadOnlyLazyList.prototype.slice = function (start, end) {
+        return new ReadOnlyLazyList(this.internalArray.slice(start, end), this.serializationService);
+    };
+    ReadOnlyLazyList.prototype.toArray = function () {
+        var arr = [];
+        var iterator = this.values();
+        for (var item = iterator.next(); !item.done; item = iterator.next()) {
+            arr.push(item.value);
+        }
+        return arr;
+    };
+    ReadOnlyLazyList.prototype[Symbol.iterator] = function () {
+        return this.values();
+    };
+    return ReadOnlyLazyList;
+}());
+exports.ReadOnlyLazyList = ReadOnlyLazyList;

package/lib/core/RestValue.d.ts

@@ -0,0 +1,15 @@
+import { IdentifiedDataSerializable, IdentifiedDataSerializableFactory } from '../serialization/Serializable';
+import { DataInput, DataOutput } from '../serialization/Data';
+export declare const REST_VALUE_FACTORY_ID = -37;
+export declare const REST_VALUE_CLASS_ID = 1;
+export declare class RestValue implements IdentifiedDataSerializable {
+    value: string;
+    contentType: string;
+    getClassId(): number;
+    getFactoryId(): number;
+    readData(input: DataInput): any;
+    writeData(output: DataOutput): void;
+}
+export declare class RestValueFactory implements IdentifiedDataSerializableFactory {
+    create(type: number): IdentifiedDataSerializable;
+}

package/lib/core/RestValue.js

@@ -0,0 +1,51 @@
+"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 });
+exports.REST_VALUE_FACTORY_ID = -37;
+exports.REST_VALUE_CLASS_ID = 1;
+var RestValue = /** @class */ (function () {
+    function RestValue() {
+    }
+    RestValue.prototype.getClassId = function () {
+        return exports.REST_VALUE_CLASS_ID;
+    };
+    RestValue.prototype.getFactoryId = function () {
+        return exports.REST_VALUE_FACTORY_ID;
+    };
+    RestValue.prototype.readData = function (input) {
+        this.value = input.readUTF();
+        this.contentType = input.readUTF();
+    };
+    RestValue.prototype.writeData = function (output) {
+        output.writeUTF(this.value);
+        output.writeUTF(this.contentType);
+    };
+    return RestValue;
+}());
+exports.RestValue = RestValue;
+var RestValueFactory = /** @class */ (function () {
+    function RestValueFactory() {
+    }
+    RestValueFactory.prototype.create = function (type) {
+        if (type === exports.REST_VALUE_CLASS_ID) {
+            return new RestValue();
+        }
+        return null;
+    };
+    return RestValueFactory;
+}());
+exports.RestValueFactory = RestValueFactory;

package/lib/core/UUID.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="long" />
+import * as Long from 'long';
+export declare class UUID {
+    readonly leastSignificant: Long;
+    readonly mostSignificant: Long;
+    constructor(mostSig: Long, leastSig: Long);
+    equals(other: UUID): boolean;
+    toString(): string;
+}

package/lib/core/UUID.js

@@ -0,0 +1,44 @@
+"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 UUID = /** @class */ (function () {
+    function UUID(mostSig, leastSig) {
+        this.mostSignificant = mostSig;
+        this.leastSignificant = leastSig;
+    }
+    UUID.prototype.equals = function (other) {
+        if (other == null) {
+            return false;
+        }
+        return other.mostSignificant.equals(this.mostSignificant) && other.leastSignificant.equals(this.leastSignificant);
+    };
+    /* tslint:disable:no-bitwise */
+    UUID.prototype.toString = function () {
+        var mostHigh = this.mostSignificant.getHighBitsUnsigned(); // (32) 32 32 32
+        var mostLow = this.mostSignificant.getLowBitsUnsigned(); // 32 (32) 32 32
+        var leastHigh = this.leastSignificant.getHighBitsUnsigned(); // 32 32 (32) 32
+        var leastLow = this.leastSignificant.getLowBitsUnsigned(); // 32 32 32 (32)
+        var div1 = mostHigh.toString(16);
+        var div2 = (mostLow >>> 16).toString(16);
+        var div3 = (mostLow & ((1 << 16) - 1)).toString(16);
+        var div4 = (leastHigh >>> 16).toString(16);
+        var div5 = (leastHigh & ((1 << 16) - 1)).toString(16) + leastLow.toString(16);
+        return div1 + '-' + div2 + '-' + div3 + '-' + div4 + '-' + div5;
+    };
+    return UUID;
+}());
+exports.UUID = UUID;

package/lib/core/VectorClock.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="long" />
+export declare class VectorClock {
+    private replicaTimestamps;
+    isAfter(other: VectorClock): boolean;
+    setReplicaTimestamp(replicaId: string, timestamp: Long): void;
+    entrySet(): Array<[string, Long]>;
+}

package/lib/core/VectorClock.js

@@ -0,0 +1,48 @@
+"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 VectorClock = /** @class */ (function () {
+    function VectorClock() {
+        this.replicaTimestamps = new Map();
+    }
+    VectorClock.prototype.isAfter = function (other) {
+        var _this = this;
+        var atLeastOneBigger = false;
+        other.replicaTimestamps.forEach(function (otherTimestamp, replicaId) {
+            var thisTimetamp = _this.replicaTimestamps.get(replicaId);
+            if (thisTimetamp == null || otherTimestamp.greaterThan(thisTimetamp)) {
+                return false;
+            }
+            else if (otherTimestamp.lessThan(thisTimetamp)) {
+                atLeastOneBigger = true;
+            }
+        });
+        return atLeastOneBigger || this.replicaTimestamps.size > other.replicaTimestamps.size;
+    };
+    VectorClock.prototype.setReplicaTimestamp = function (replicaId, timestamp) {
+        this.replicaTimestamps.set(replicaId, timestamp);
+    };
+    VectorClock.prototype.entrySet = function () {
+        var entrySet = [];
+        this.replicaTimestamps.forEach(function (timestamp, replicaId) {
+            entrySet.push([replicaId, timestamp]);
+        });
+        return entrySet;
+    };
+    return VectorClock;
+}());
+exports.VectorClock = VectorClock;

package/lib/discovery/HazelcastCloudAddressProvider.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="bluebird" />
+import { AddressProvider } from '../connection/AddressProvider';
+import * as Promise from 'bluebird';
+import { ILogger } from '../logging/ILogger';
+export declare class HazelcastCloudAddressProvider implements AddressProvider {
+    private readonly logger;
+    private readonly cloudDiscovery;
+    constructor(endpointUrl: string, connectionTimeoutMillis: number, logger: ILogger);
+    loadAddresses(): Promise<string[]>;
+}

package/lib/discovery/HazelcastCloudAddressProvider.js

@@ -0,0 +1,35 @@
+"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 HazelcastCloudDiscovery_1 = require("./HazelcastCloudDiscovery");
+var HazelcastCloudAddressProvider = /** @class */ (function () {
+    function HazelcastCloudAddressProvider(endpointUrl, connectionTimeoutMillis, logger) {
+        this.cloudDiscovery = new HazelcastCloudDiscovery_1.HazelcastCloudDiscovery(endpointUrl, connectionTimeoutMillis);
+        this.logger = logger;
+    }
+    HazelcastCloudAddressProvider.prototype.loadAddresses = function () {
+        var _this = this;
+        return this.cloudDiscovery.discoverNodes().then(function (res) {
+            return Array.from(res.keys());
+        }).catch(function (e) {
+            _this.logger.warn('HazelcastCloudAddressProvider', 'Failed to load addresses from hazelcast.cloud : ' + e.message);
+            return [];
+        });
+    };
+    return HazelcastCloudAddressProvider;
+}());
+exports.HazelcastCloudAddressProvider = HazelcastCloudAddressProvider;

package/lib/discovery/HazelcastCloudAddressTranslator.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="bluebird" />
+import { AddressTranslator } from '../connection/AddressTranslator';
+import * as Promise from 'bluebird';
+import Address = require('../Address');
+import { ILogger } from '../logging/ILogger';
+export declare class HazelcastCloudAddressTranslator implements AddressTranslator {
+    private logger;
+    private readonly hazelcastCloudDiscovery;
+    private privateToPublic;
+    constructor(endpointUrl: string, connectionTimeoutMillis: number, logger: ILogger);
+    translate(address: Address): Promise<Address>;
+    refresh(): Promise<void>;
+}

package/lib/discovery/HazelcastCloudAddressTranslator.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 });
+var HazelcastCloudDiscovery_1 = require("./HazelcastCloudDiscovery");
+var Promise = require("bluebird");
+var HazelcastCloudAddressTranslator = /** @class */ (function () {
+    function HazelcastCloudAddressTranslator(endpointUrl, connectionTimeoutMillis, logger) {
+        this.privateToPublic = new Map();
+        this.hazelcastCloudDiscovery = new HazelcastCloudDiscovery_1.HazelcastCloudDiscovery(endpointUrl, connectionTimeoutMillis);
+        this.logger = logger;
+    }
+    HazelcastCloudAddressTranslator.prototype.translate = function (address) {
+        var _this = this;
+        if (address == null) {
+            return Promise.resolve(null);
+        }
+        var publicAddress = this.privateToPublic.get(address.toString());
+        if (publicAddress != null) {
+            return Promise.resolve(publicAddress);
+        }
+        return this.refresh().then(function () {
+            if (_this.privateToPublic.get(address.toString())) {
+                return _this.privateToPublic.get(address.toString());
+            }
+            else {
+                return null;
+            }
+        });
+    };
+    HazelcastCloudAddressTranslator.prototype.refresh = function () {
+        var _this = this;
+        return this.hazelcastCloudDiscovery.discoverNodes().then(function (res) {
+            _this.privateToPublic = res;
+        }).catch(function (e) {
+            _this.logger.warn('HazelcastCloudAddressTranslator', 'Failed to load addresses from hazelcast.cloud : ' + e.message);
+        });
+    };
+    return HazelcastCloudAddressTranslator;
+}());
+exports.HazelcastCloudAddressTranslator = HazelcastCloudAddressTranslator;

package/lib/discovery/HazelcastCloudDiscovery.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="bluebird" />
+import Address = require('../Address');
+import * as Promise from 'bluebird';
+import { Properties } from '../config/Properties';
+/**
+ * Discovery service that discover nodes via hazelcast.cloud
+ * https://coordinator.hazelcast.cloud/cluster/discovery?token=<TOKEN>
+ */
+export declare class HazelcastCloudDiscovery {
+    /**
+     * Internal client property to change base url of cloud discovery endpoint.
+     * Used for testing cloud discovery.
+     */
+    private static readonly CLOUD_URL_BASE_PROPERTY;
+    private static readonly CLOUD_URL_PATH;
+    private static readonly PRIVATE_ADDRESS_PROPERTY;
+    private static readonly PUBLIC_ADDRESS_PROPERTY;
+    private readonly endpointUrl;
+    private readonly connectionTimeoutInMillis;
+    constructor(endpointUrl: string, connectionTimeoutInMillis: number);
+    static createUrlEndpoint(properties: Properties, cloudToken: string): string;
+    discoverNodes(): Promise<Map<string, Address>>;
+    callService(): Promise<Map<string, Address>>;
+    private parseResponse(data);
+}

package/lib/discovery/HazelcastCloudDiscovery.js

@@ -0,0 +1,85 @@
+"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 Util_1 = require("../Util");
+var https_1 = require("https");
+var URL = require("url");
+/**
+ * Discovery service that discover nodes via hazelcast.cloud
+ * https://coordinator.hazelcast.cloud/cluster/discovery?token=<TOKEN>
+ */
+var HazelcastCloudDiscovery = /** @class */ (function () {
+    function HazelcastCloudDiscovery(endpointUrl, connectionTimeoutInMillis) {
+        this.endpointUrl = endpointUrl;
+        this.connectionTimeoutInMillis = connectionTimeoutInMillis;
+    }
+    HazelcastCloudDiscovery.createUrlEndpoint = function (properties, cloudToken) {
+        var cloudBaseUrl = properties[HazelcastCloudDiscovery.CLOUD_URL_BASE_PROPERTY];
+        return cloudBaseUrl + this.CLOUD_URL_PATH + cloudToken;
+    };
+    HazelcastCloudDiscovery.prototype.discoverNodes = function () {
+        return this.callService().catch(function (e) {
+            throw e;
+        });
+    };
+    HazelcastCloudDiscovery.prototype.callService = function () {
+        var _this = this;
+        var deferred = Util_1.DeferredPromise();
+        var url = URL.parse(this.endpointUrl);
+        var endpointUrlOptions = {
+            host: url.host,
+            path: url.path,
+        };
+        var dataAsAString = '';
+        https_1.get(endpointUrlOptions, function (res) {
+            res.setEncoding('utf8');
+            res.on('data', function (chunk) {
+                dataAsAString += chunk;
+            });
+            res.on('end', function () {
+                deferred.resolve(_this.parseResponse(dataAsAString));
+            });
+        }).on('error', function (e) {
+            deferred.reject(e);
+        });
+        return deferred.promise;
+    };
+    HazelcastCloudDiscovery.prototype.parseResponse = function (data) {
+        var jsonValue = JSON.parse(data);
+        var privateToPublicAddresses = new Map();
+        for (var _i = 0, jsonValue_1 = jsonValue; _i < jsonValue_1.length; _i++) {
+            var value = jsonValue_1[_i];
+            var privateAddress = value[HazelcastCloudDiscovery.PRIVATE_ADDRESS_PROPERTY];
+            var publicAddress = value[HazelcastCloudDiscovery.PUBLIC_ADDRESS_PROPERTY];
+            var publicAddr = Util_1.AddressHelper.createAddressFromString(publicAddress.toString(), -1);
+            // If not explicitly given, create the private address with the public addresses port
+            var privateAddr = Util_1.AddressHelper.createAddressFromString(privateAddress.toString(), publicAddr.port);
+            privateToPublicAddresses.set(privateAddr.toString(), publicAddr);
+        }
+        return privateToPublicAddresses;
+    };
+    /**
+     * Internal client property to change base url of cloud discovery endpoint.
+     * Used for testing cloud discovery.
+     */
+    HazelcastCloudDiscovery.CLOUD_URL_BASE_PROPERTY = 'hazelcast.client.cloud.url';
+    HazelcastCloudDiscovery.CLOUD_URL_PATH = '/cluster/discovery?token=';
+    HazelcastCloudDiscovery.PRIVATE_ADDRESS_PROPERTY = 'private-address';
+    HazelcastCloudDiscovery.PUBLIC_ADDRESS_PROPERTY = 'public-address';
+    return HazelcastCloudDiscovery;
+}());
+exports.HazelcastCloudDiscovery = HazelcastCloudDiscovery;

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import Address = require('./Address');
+import TopicOverloadPolicy = require('./proxy/topic/TopicOverloadPolicy');
+import * as Aggregators from './aggregation/Aggregators';
+import { ClientInfo } from './ClientInfo';
+import * as Config from './config/Config';
+import { ConfigBuilder } from './config/ConfigBuilder';
+import { ImportConfig } from './config/ImportConfig';
+import * as Predicates from './core/Predicate';
+import { IterationType } from './core/Predicate';
+import HazelcastClient from './HazelcastClient';
+import * as HazelcastErrors from './HazelcastError';
+import { IMap } from './proxy/IMap';
+import { ReadResultSet } from './proxy/ringbuffer/ReadResultSet';
+import { ClassDefinitionBuilder } from './serialization/portable/ClassDefinitionBuilder';
+import { ClassDefinition, FieldDefinition } from './serialization/portable/ClassDefinition';
+import { MemberAttributeEvent, MemberAttributeOperationType } from './core/MemberAttributeEvent';
+import { EvictionPolicy } from './config/EvictionPolicy';
+import { InMemoryFormat } from './config/InMemoryFormat';
+import { ItemEvent, ItemEventType } from './core/ItemListener';
+import { MapEvent } from './core/MapListener';
+import { EntryEvent } from './core/EntryListener';
+import { LogLevel } from './logging/LoggingService';
+import { JsonStringDeserializationPolicy } from './config/JsonStringDeserializationPolicy';
+import { HazelcastJsonValue } from './core/HazelcastJsonValue';
+import { StringSerializationPolicy } from './config/StringSerializationPolicy';
+export { HazelcastClient as Client, Config, ConfigBuilder, ClientInfo, IMap, Address, Predicates, TopicOverloadPolicy, HazelcastErrors, ReadResultSet, IterationType, Aggregators, ImportConfig, FieldDefinition, ClassDefinition, ClassDefinitionBuilder, MemberAttributeEvent, MemberAttributeOperationType, EvictionPolicy, InMemoryFormat, ItemEvent, ItemEventType, MapEvent, EntryEvent, LogLevel, JsonStringDeserializationPolicy, HazelcastJsonValue, StringSerializationPolicy };