@celerispay/hazelcast-client 3.12.5

package/lib/config/SerializationConfig.d.ts

@@ -0,0 +1,29 @@
+import { IdentifiedDataSerializableFactory, PortableFactory } from '../serialization/Serializable';
+import { ImportConfig } from './ImportConfig';
+import { JsonStringDeserializationPolicy } from './JsonStringDeserializationPolicy';
+import { StringSerializationPolicy } from './StringSerializationPolicy';
+export declare class SerializationConfig {
+    defaultNumberType: string;
+    isBigEndian: boolean;
+    dataSerializableFactories: {
+        [id: number]: IdentifiedDataSerializableFactory;
+    };
+    dataSerializableFactoryConfigs: {
+        [id: number]: ImportConfig;
+    };
+    portableFactories: {
+        [id: number]: PortableFactory;
+    };
+    portableFactoryConfigs: {
+        [id: number]: ImportConfig;
+    };
+    portableVersion: number;
+    customSerializers: any[];
+    customSerializerConfigs: {
+        [id: number]: ImportConfig;
+    };
+    globalSerializer: any;
+    globalSerializerConfig: ImportConfig;
+    jsonStringDeserializationPolicy: JsonStringDeserializationPolicy;
+    stringSerializationPolicy: StringSerializationPolicy;
+}

package/lib/config/SerializationConfig.js

@@ -0,0 +1,38 @@
+"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 JsonStringDeserializationPolicy_1 = require("./JsonStringDeserializationPolicy");
+var StringSerializationPolicy_1 = require("./StringSerializationPolicy");
+var SerializationConfig = /** @class */ (function () {
+    function SerializationConfig() {
+        this.defaultNumberType = 'double';
+        this.isBigEndian = true;
+        this.dataSerializableFactories = {};
+        this.dataSerializableFactoryConfigs = {};
+        this.portableFactories = {};
+        this.portableFactoryConfigs = {};
+        this.portableVersion = 0;
+        this.customSerializers = [];
+        this.customSerializerConfigs = {};
+        this.globalSerializer = null;
+        this.globalSerializerConfig = null;
+        this.jsonStringDeserializationPolicy = JsonStringDeserializationPolicy_1.JsonStringDeserializationPolicy.EAGER;
+        this.stringSerializationPolicy = StringSerializationPolicy_1.StringSerializationPolicy.STANDARD;
+    }
+    return SerializationConfig;
+}());
+exports.SerializationConfig = SerializationConfig;

package/lib/config/StringSerializationPolicy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Using this policy, one can control the
+ * serialization type of strings.
+ */
+export declare enum StringSerializationPolicy {
+    /**
+     * Strings are serialized and deserialized
+     * according to UTF-8 standard (RFC 3629).
+     *
+     * May lead to server-side compatibility
+     * issues with IMDG 3.x for 4 byte characters,
+     * like less common CJK characters and emoji.
+     */
+    STANDARD = 0,
+    /**
+     * 4 byte characters are represented as
+     * 6 bytes during serialization/deserialization
+     * (non-standard UTF-8). Provides full compatibility
+     * with IMDG 3.x members and other clients.
+     */
+    LEGACY = 1,
+}

package/lib/config/StringSerializationPolicy.js

@@ -0,0 +1,40 @@
+"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 });
+/**
+ * Using this policy, one can control the
+ * serialization type of strings.
+ */
+var StringSerializationPolicy;
+(function (StringSerializationPolicy) {
+    /**
+     * Strings are serialized and deserialized
+     * according to UTF-8 standard (RFC 3629).
+     *
+     * May lead to server-side compatibility
+     * issues with IMDG 3.x for 4 byte characters,
+     * like less common CJK characters and emoji.
+     */
+    StringSerializationPolicy[StringSerializationPolicy["STANDARD"] = 0] = "STANDARD";
+    /**
+     * 4 byte characters are represented as
+     * 6 bytes during serialization/deserialization
+     * (non-standard UTF-8). Provides full compatibility
+     * with IMDG 3.x members and other clients.
+     */
+    StringSerializationPolicy[StringSerializationPolicy["LEGACY"] = 1] = "LEGACY";
+})(StringSerializationPolicy = exports.StringSerializationPolicy || (exports.StringSerializationPolicy = {}));

package/lib/connection/AddressProvider.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+/**
+ * Provides initial addresses for client to find and connect to a node
+ */
+export interface AddressProvider {
+    /**
+     * @return The possible member addresses to connect to.
+     */
+    loadAddresses(): Promise<string[]>;
+}

package/lib/connection/AddressProvider.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 });

package/lib/connection/AddressTranslator.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="bluebird" />
+import Address = require('../Address');
+import * as Promise from 'bluebird';
+/**
+ *  Address Translator is used for resolve private ip
+ *  addresses of cloud services.
+ */
+export interface AddressTranslator {
+    /**
+     * Translates the given address to another address specific to
+     * network or service
+     *
+     * @param address
+     * @return new address if given address is known, otherwise return null
+     */
+    translate(address: Address): Promise<Address>;
+    /**
+     * Refreshes the internal lookup table if necessary.
+     */
+    refresh(): Promise<void>;
+}

package/lib/connection/AddressTranslator.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 });

package/lib/connection/BasicSSLOptionsFactory.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { Properties } from '../config/Properties';
+import { SSLOptionsFactory } from './SSLOptionsFactory';
+export declare class BasicSSLOptionsFactory implements SSLOptionsFactory {
+    private servername;
+    private rejectUnauthorized;
+    private ca;
+    private key;
+    private cert;
+    private ciphers;
+    init(properties: Properties): Promise<void>;
+    getSSLOptions(): any;
+}

package/lib/connection/BasicSSLOptionsFactory.js

@@ -0,0 +1,67 @@
+"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 Promise = require("bluebird");
+var fs = require("fs");
+var HazelcastError_1 = require("../HazelcastError");
+var Util_1 = require("../Util");
+var BasicSSLOptionsFactory = /** @class */ (function () {
+    function BasicSSLOptionsFactory() {
+    }
+    BasicSSLOptionsFactory.prototype.init = function (properties) {
+        var _this = this;
+        if (typeof properties !== 'object') {
+            throw new HazelcastError_1.HazelcastError('properties is not an object');
+        }
+        var promises = [];
+        var readFile = Promise.promisify(fs.readFile);
+        var caPath = Util_1.getStringOrUndefined(properties.caPath);
+        var keyPath = Util_1.getStringOrUndefined(properties.keyPath);
+        var certPath = Util_1.getStringOrUndefined(properties.certPath);
+        if (caPath !== undefined) {
+            promises.push(readFile(Util_1.resolvePath(caPath)).then(function (data) {
+                _this.ca = data;
+            }));
+        }
+        if (keyPath !== undefined) {
+            promises.push(readFile(Util_1.resolvePath(keyPath)).then(function (data) {
+                _this.key = data;
+            }));
+        }
+        if (certPath !== undefined) {
+            promises.push(readFile(Util_1.resolvePath(certPath)).then(function (data) {
+                _this.cert = data;
+            }));
+        }
+        this.servername = Util_1.getStringOrUndefined(properties.servername);
+        this.rejectUnauthorized = Util_1.getBooleanOrUndefined(properties.rejectUnauthorized);
+        this.ciphers = Util_1.getStringOrUndefined(properties.ciphers);
+        return Promise.all(promises).return();
+    };
+    BasicSSLOptionsFactory.prototype.getSSLOptions = function () {
+        return {
+            servername: this.servername,
+            rejectUnauthorized: this.rejectUnauthorized,
+            ca: this.ca,
+            key: this.key,
+            cert: this.cert,
+            ciphers: this.ciphers,
+        };
+    };
+    return BasicSSLOptionsFactory;
+}());
+exports.BasicSSLOptionsFactory = BasicSSLOptionsFactory;

package/lib/connection/DefaultAddressProvider.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="bluebird" />
+import { AddressProvider } from './AddressProvider';
+import { ClientNetworkConfig } from '../config/ClientNetworkConfig';
+import * as Promise from 'bluebird';
+/**
+ * Default address provider of Hazelcast.
+ *
+ * Loads addresses from the Hazelcast configuration.
+ */
+export declare class DefaultAddressProvider implements AddressProvider {
+    private networkConfig;
+    private readonly noOtherAddressProviderExist;
+    constructor(networkConfig: ClientNetworkConfig, noOtherAddressProviderExist: boolean);
+    loadAddresses(): Promise<string[]>;
+}

package/lib/connection/DefaultAddressProvider.js

@@ -0,0 +1,38 @@
+"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 Promise = require("bluebird");
+/**
+ * Default address provider of Hazelcast.
+ *
+ * Loads addresses from the Hazelcast configuration.
+ */
+var DefaultAddressProvider = /** @class */ (function () {
+    function DefaultAddressProvider(networkConfig, noOtherAddressProviderExist) {
+        this.networkConfig = networkConfig;
+        this.noOtherAddressProviderExist = noOtherAddressProviderExist;
+    }
+    DefaultAddressProvider.prototype.loadAddresses = function () {
+        var addresses = this.networkConfig.addresses;
+        if (addresses.length === 0 && this.noOtherAddressProviderExist) {
+            addresses.push('localhost:5701');
+        }
+        return Promise.resolve(addresses);
+    };
+    return DefaultAddressProvider;
+}());
+exports.DefaultAddressProvider = DefaultAddressProvider;

package/lib/connection/DefaultAddressTranslator.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bluebird" />
+import { AddressTranslator } from './AddressTranslator';
+import * as Promise from 'bluebird';
+import Address = require('../Address');
+/**
+ * Default Address Translator is a no-op. It always returns the given address.
+ */
+export declare class DefaultAddressTranslator implements AddressTranslator {
+    refresh(): Promise<void>;
+    translate(address: Address): Promise<Address>;
+}

package/lib/connection/DefaultAddressTranslator.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var Promise = require("bluebird");
+/**
+ * Default Address Translator is a no-op. It always returns the given address.
+ */
+var DefaultAddressTranslator = /** @class */ (function () {
+    function DefaultAddressTranslator() {
+    }
+    DefaultAddressTranslator.prototype.refresh = function () {
+        return Promise.resolve();
+    };
+    DefaultAddressTranslator.prototype.translate = function (address) {
+        return Promise.resolve(address);
+    };
+    return DefaultAddressTranslator;
+}());
+exports.DefaultAddressTranslator = DefaultAddressTranslator;

package/lib/connection/SSLOptionsFactory.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { Properties } from '../config/Properties';
+export interface SSLOptionsFactory {
+    init(properties: Properties): Promise<void>;
+    getSSLOptions(): any;
+}

package/lib/connection/SSLOptionsFactory.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 });

package/lib/core/Comparator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Comparator is used to compare two map entries in a distributed map.
+ * A comparator class with the same functionality should be registered
+ * on Hazelcast server in order to be used in {PagingPredicate}s.
+ *
+ */
+export interface Comparator {
+    /**
+     * This method is used to determine order of entries when sorting.
+     *  - If return value is a negative value, {a} comes after {b},
+     *  - If return value is a positive value, {a} comes before {b},
+     *  - If return value is 0, {a} and {b} are indistinguishable in this sorting mechanism.
+     *      Their order with respect to each other is undefined.
+     * This method must always return the same result given the same pair of keys.
+     * @param a first entry
+     * @param b second entry
+     * @return order index
+     *
+     */
+    sort(a: [any, any], b: [any, any]): number;
+}

package/lib/core/Comparator.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 });

package/lib/core/ConnectionHeartbeatListener.d.ts

@@ -0,0 +1,16 @@
+import { ClientConnection } from '../invocation/ClientConnection';
+/**
+ * Listener interface for heartbeat service.
+ */
+export interface ConnectionHeartbeatListener {
+    /**
+     * Invoked when heartbeat of a server is restored after stopped.
+     * @param connection connection object associated with that server node.
+     */
+    onHeartbeatRestored?: (connection?: ClientConnection) => void;
+    /**
+     * Invoked when heartbeat of a server node failed.
+     * @param connection connection object associated with that server node.
+     */
+    onHeartbeatStopped?: (connection?: ClientConnection) => void;
+}

package/lib/core/ConnectionHeartbeatListener.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 });

package/lib/core/DistributedObjectListener.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DistributedObjectListener notifies when a DistributedObject
+ * is created or destroyed cluster-wide.
+ */
+export declare type DistributedObjectListener = (distributedObjectListener: DistributedObjectEvent) => void;
+/**
+ * DistributedObjectEvent is fired when a DistributedObject
+ * is created or destroyed cluster-wide.
+ */
+export declare class DistributedObjectEvent {
+    /**
+     * The type of this event; one of 'created' or 'destroyed'.
+     */
+    eventType: string;
+    /**
+     * The service name of related DistributedObject.
+     */
+    serviceName: string;
+    /**
+     * The name of related DistributedObject.
+     */
+    objectName: string;
+    constructor(eventType: string, serviceName: string, objectName: string);
+}

package/lib/core/DistributedObjectListener.js

@@ -0,0 +1,30 @@
+"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 });
+/**
+ * DistributedObjectEvent is fired when a DistributedObject
+ * is created or destroyed cluster-wide.
+ */
+var DistributedObjectEvent = /** @class */ (function () {
+    function DistributedObjectEvent(eventType, serviceName, objectName) {
+        this.eventType = eventType;
+        this.serviceName = serviceName;
+        this.objectName = objectName;
+    }
+    return DistributedObjectEvent;
+}());
+exports.DistributedObjectEvent = DistributedObjectEvent;

package/lib/core/EntryListener.d.ts

@@ -0,0 +1,51 @@
+import { MapEventListener } from './MapListener';
+import { Member } from './Member';
+/**
+ * An interface which is used to get notified upon a map or an entry event.
+ */
+export interface EntryListener<K, V> {
+    added?: EntryEventListener<K, V>;
+    removed?: EntryEventListener<K, V>;
+    updated?: EntryEventListener<K, V>;
+    merged?: EntryEventListener<K, V>;
+    evicted?: EntryEventListener<K, V>;
+    expired?: EntryEventListener<K, V>;
+    loaded?: EntryEventListener<K, V>;
+    mapEvicted?: MapEventListener<K, V>;
+    mapCleared?: MapEventListener<K, V>;
+    [event: string]: EntryEventListener<K, V> | MapEventListener<K, V>;
+}
+/**
+ * A type which is used for entry events.
+ */
+export declare type EntryEventListener<K, V> = (entryEvent: EntryEvent<K, V>) => void;
+/**
+ * Map Entry event.
+ */
+export declare class EntryEvent<K, V> {
+    /**
+     * The name of the map for this event.
+     */
+    name: string;
+    /**
+     * The key of the entry event.
+     */
+    key: K;
+    /**
+     * The value of the entry event.
+     */
+    value: V;
+    /**
+     * The old value of the entry event.
+     */
+    oldValue: V;
+    /**
+     * The incoming merging value of the entry event.
+     */
+    mergingValue: V;
+    /**
+     * The member that fired this event.
+     */
+    member: Member;
+    constructor(name: string, key: K, value: V, oldValue: V, mergingValue: V, member: Member);
+}

package/lib/core/EntryListener.js

@@ -0,0 +1,32 @@
+"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 });
+/**
+ * Map Entry event.
+ */
+var EntryEvent = /** @class */ (function () {
+    function EntryEvent(name, key, value, oldValue, mergingValue, member) {
+        this.name = name;
+        this.key = key;
+        this.value = value;
+        this.oldValue = oldValue;
+        this.mergingValue = mergingValue;
+        this.member = member;
+    }
+    return EntryEvent;
+}());
+exports.EntryEvent = EntryEvent;

package/lib/core/EntryView.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="long" />
+import * as Long from 'long';
+export declare class EntryView<K, V> {
+    key: K;
+    value: V;
+    cost: Long;
+    creationTime: Long;
+    expirationTime: Long;
+    hits: Long;
+    lastAccessTime: Long;
+    lastStoreTime: Long;
+    lastUpdateTime: Long;
+    version: Long;
+    evictionCriteriaNumber: Long;
+    ttl: Long;
+}