@celerispay/hazelcast-client 3.12.5

package/lib/protocol/ClientProtocolErrorCodes.d.ts

@@ -0,0 +1,91 @@
+export declare class ClientProtocolErrorCodes {
+    static readonly UNDEFINED: number;
+    static readonly ARRAY_INDEX_OUT_OF_BOUNDS: number;
+    static readonly ARRAY_STORE: number;
+    static readonly AUTHENTICATION: number;
+    static readonly CACHE: number;
+    static readonly CACHE_LOADER: number;
+    static readonly CACHE_NOT_EXISTS: number;
+    static readonly CACHE_WRITER: number;
+    static readonly CALLER_NOT_MEMBER: number;
+    static readonly CANCELLATION: number;
+    static readonly CLASS_CAST: number;
+    static readonly CLASS_NOT_FOUND: number;
+    static readonly CONCURRENT_MODIFICATION: number;
+    static readonly CONFIG_MISMATCH: number;
+    static readonly CONFIGURATION: number;
+    static readonly DISTRIBUTED_OBJECT_DESTROYED: number;
+    static readonly DUPLICATE_INSTANCE_NAME: number;
+    static readonly EOF: number;
+    static readonly ENTRY_PROCESSOR: number;
+    static readonly EXECUTION: number;
+    static readonly HAZELCAST: number;
+    static readonly HAZELCAST_INSTANCE_NOT_ACTIVE: number;
+    static readonly HAZELCAST_OVERLOAD: number;
+    static readonly HAZELCAST_SERIALIZATION: number;
+    static readonly IO: number;
+    static readonly ILLEGAL_ARGUMENT: number;
+    static readonly ILLEGAL_ACCESS_EXCEPTION: number;
+    static readonly ILLEGAL_ACCESS_ERROR: number;
+    static readonly ILLEGAL_MONITOR_STATE: number;
+    static readonly ILLEGAL_STATE: number;
+    static readonly ILLEGAL_THREAD_STATE: number;
+    static readonly INDEX_OUT_OF_BOUNDS: number;
+    static readonly INTERRUPTED: number;
+    static readonly INVALID_ADDRESS: number;
+    static readonly INVALID_CONFIGURATION: number;
+    static readonly MEMBER_LEFT: number;
+    static readonly NEGATIVE_ARRAY_SIZE: number;
+    static readonly NO_SUCH_ELEMENT: number;
+    static readonly NOT_SERIALIZABLE: number;
+    static readonly NULL_POINTER: number;
+    static readonly OPERATION_TIMEOUT: number;
+    static readonly PARTITION_MIGRATING: number;
+    static readonly QUERY: number;
+    static readonly QUERY_RESULT_SIZE_EXCEEDED: number;
+    static readonly QUORUM: number;
+    static readonly REACHED_MAX_SIZE: number;
+    static readonly REJECTED_EXECUTION: number;
+    static readonly REMOTE_MAP_REDUCE: number;
+    static readonly RESPONSE_ALREADY_SENT: number;
+    static readonly RETRYABLE_HAZELCAST: number;
+    static readonly RETRYABLE_IO: number;
+    static readonly RUNTIME: number;
+    static readonly SECURITY: number;
+    static readonly SOCKET: number;
+    static readonly STALE_SEQUENCE: number;
+    static readonly TARGET_DISCONNECTED: number;
+    static readonly TARGET_NOT_MEMBER: number;
+    static readonly TIMEOUT: number;
+    static readonly TOPIC_OVERLOAD: number;
+    static readonly TOPOLOGY_CHANGED: number;
+    static readonly TRANSACTION: number;
+    static readonly TRANSACTION_NOT_ACTIVE: number;
+    static readonly TRANSACTION_TIMED_OUT: number;
+    static readonly URI_SYNTAX: number;
+    static readonly UTF_DATA_FORMAT: number;
+    static readonly UNSUPPORTED_OPERATION: number;
+    static readonly WRONG_TARGET: number;
+    static readonly XA: number;
+    static readonly ACCESS_CONTROL: number;
+    static readonly LOGIN: number;
+    static readonly UNSUPPORTED_CALLBACK: number;
+    static readonly NO_DATA_MEMBER: number;
+    static readonly REPLICATED_MAP_CANT_BE_CREATED: number;
+    static readonly MAX_MESSAGE_SIZE_EXCEEDED: number;
+    static readonly WAN_REPLICATION_QUEUE_FULL: number;
+    static readonly ASSERTION_ERROR: number;
+    static readonly OUT_OF_MEMORY_ERROR: number;
+    static readonly STACK_OVERFLOW_ERROR: number;
+    static readonly NATIVE_OUT_OF_MEMORY_ERROR: number;
+    static readonly SERVICE_NOT_FOUND: number;
+    static readonly STALE_TASK_ID: number;
+    static readonly DUPLICATE_TASK: number;
+    static readonly STALE_TASK: number;
+    static readonly LOCAL_MEMBER_RESET: number;
+    static readonly INDETERMINATE_OPERATION_STATE: number;
+    static readonly FLAKE_ID_NODE_ID_OUT_OF_RANGE_EXCEPTION: number;
+    static readonly TARGET_NOT_REPLICA_EXCEPTION: number;
+    static readonly MUTATION_DISALLOWED_EXCEPTION: number;
+    static readonly CONSISTENCY_LOST_EXCEPTION: number;
+}

package/lib/protocol/ClientProtocolErrorCodes.js

@@ -0,0 +1,112 @@
+"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 ClientProtocolErrorCodes = /** @class */ (function () {
+    function ClientProtocolErrorCodes() {
+    }
+    ClientProtocolErrorCodes.UNDEFINED = 0;
+    ClientProtocolErrorCodes.ARRAY_INDEX_OUT_OF_BOUNDS = 1;
+    ClientProtocolErrorCodes.ARRAY_STORE = 2;
+    ClientProtocolErrorCodes.AUTHENTICATION = 3;
+    ClientProtocolErrorCodes.CACHE = 4;
+    ClientProtocolErrorCodes.CACHE_LOADER = 5;
+    ClientProtocolErrorCodes.CACHE_NOT_EXISTS = 6;
+    ClientProtocolErrorCodes.CACHE_WRITER = 7;
+    ClientProtocolErrorCodes.CALLER_NOT_MEMBER = 8;
+    ClientProtocolErrorCodes.CANCELLATION = 9;
+    ClientProtocolErrorCodes.CLASS_CAST = 10;
+    ClientProtocolErrorCodes.CLASS_NOT_FOUND = 11;
+    ClientProtocolErrorCodes.CONCURRENT_MODIFICATION = 12;
+    ClientProtocolErrorCodes.CONFIG_MISMATCH = 13;
+    ClientProtocolErrorCodes.CONFIGURATION = 14;
+    ClientProtocolErrorCodes.DISTRIBUTED_OBJECT_DESTROYED = 15;
+    ClientProtocolErrorCodes.DUPLICATE_INSTANCE_NAME = 16;
+    ClientProtocolErrorCodes.EOF = 17;
+    ClientProtocolErrorCodes.ENTRY_PROCESSOR = 18;
+    ClientProtocolErrorCodes.EXECUTION = 19;
+    ClientProtocolErrorCodes.HAZELCAST = 20;
+    ClientProtocolErrorCodes.HAZELCAST_INSTANCE_NOT_ACTIVE = 21;
+    ClientProtocolErrorCodes.HAZELCAST_OVERLOAD = 22;
+    ClientProtocolErrorCodes.HAZELCAST_SERIALIZATION = 23;
+    ClientProtocolErrorCodes.IO = 24;
+    ClientProtocolErrorCodes.ILLEGAL_ARGUMENT = 25;
+    ClientProtocolErrorCodes.ILLEGAL_ACCESS_EXCEPTION = 26;
+    ClientProtocolErrorCodes.ILLEGAL_ACCESS_ERROR = 27;
+    ClientProtocolErrorCodes.ILLEGAL_MONITOR_STATE = 28;
+    ClientProtocolErrorCodes.ILLEGAL_STATE = 29;
+    ClientProtocolErrorCodes.ILLEGAL_THREAD_STATE = 30;
+    ClientProtocolErrorCodes.INDEX_OUT_OF_BOUNDS = 31;
+    ClientProtocolErrorCodes.INTERRUPTED = 32;
+    ClientProtocolErrorCodes.INVALID_ADDRESS = 33;
+    ClientProtocolErrorCodes.INVALID_CONFIGURATION = 34;
+    ClientProtocolErrorCodes.MEMBER_LEFT = 35;
+    ClientProtocolErrorCodes.NEGATIVE_ARRAY_SIZE = 36;
+    ClientProtocolErrorCodes.NO_SUCH_ELEMENT = 37;
+    ClientProtocolErrorCodes.NOT_SERIALIZABLE = 38;
+    ClientProtocolErrorCodes.NULL_POINTER = 39;
+    ClientProtocolErrorCodes.OPERATION_TIMEOUT = 40;
+    ClientProtocolErrorCodes.PARTITION_MIGRATING = 41;
+    ClientProtocolErrorCodes.QUERY = 42;
+    ClientProtocolErrorCodes.QUERY_RESULT_SIZE_EXCEEDED = 43;
+    ClientProtocolErrorCodes.QUORUM = 44;
+    ClientProtocolErrorCodes.REACHED_MAX_SIZE = 45;
+    ClientProtocolErrorCodes.REJECTED_EXECUTION = 46;
+    ClientProtocolErrorCodes.REMOTE_MAP_REDUCE = 47;
+    ClientProtocolErrorCodes.RESPONSE_ALREADY_SENT = 48;
+    ClientProtocolErrorCodes.RETRYABLE_HAZELCAST = 49;
+    ClientProtocolErrorCodes.RETRYABLE_IO = 50;
+    ClientProtocolErrorCodes.RUNTIME = 51;
+    ClientProtocolErrorCodes.SECURITY = 52;
+    ClientProtocolErrorCodes.SOCKET = 53;
+    ClientProtocolErrorCodes.STALE_SEQUENCE = 54;
+    ClientProtocolErrorCodes.TARGET_DISCONNECTED = 55;
+    ClientProtocolErrorCodes.TARGET_NOT_MEMBER = 56;
+    ClientProtocolErrorCodes.TIMEOUT = 57;
+    ClientProtocolErrorCodes.TOPIC_OVERLOAD = 58;
+    ClientProtocolErrorCodes.TOPOLOGY_CHANGED = 59;
+    ClientProtocolErrorCodes.TRANSACTION = 60;
+    ClientProtocolErrorCodes.TRANSACTION_NOT_ACTIVE = 61;
+    ClientProtocolErrorCodes.TRANSACTION_TIMED_OUT = 62;
+    ClientProtocolErrorCodes.URI_SYNTAX = 63;
+    ClientProtocolErrorCodes.UTF_DATA_FORMAT = 64;
+    ClientProtocolErrorCodes.UNSUPPORTED_OPERATION = 65;
+    ClientProtocolErrorCodes.WRONG_TARGET = 66;
+    ClientProtocolErrorCodes.XA = 67;
+    ClientProtocolErrorCodes.ACCESS_CONTROL = 68;
+    ClientProtocolErrorCodes.LOGIN = 69;
+    ClientProtocolErrorCodes.UNSUPPORTED_CALLBACK = 70;
+    ClientProtocolErrorCodes.NO_DATA_MEMBER = 71;
+    ClientProtocolErrorCodes.REPLICATED_MAP_CANT_BE_CREATED = 72;
+    ClientProtocolErrorCodes.MAX_MESSAGE_SIZE_EXCEEDED = 73;
+    ClientProtocolErrorCodes.WAN_REPLICATION_QUEUE_FULL = 74;
+    ClientProtocolErrorCodes.ASSERTION_ERROR = 75;
+    ClientProtocolErrorCodes.OUT_OF_MEMORY_ERROR = 76;
+    ClientProtocolErrorCodes.STACK_OVERFLOW_ERROR = 77;
+    ClientProtocolErrorCodes.NATIVE_OUT_OF_MEMORY_ERROR = 78;
+    ClientProtocolErrorCodes.SERVICE_NOT_FOUND = 79;
+    ClientProtocolErrorCodes.STALE_TASK_ID = 80;
+    ClientProtocolErrorCodes.DUPLICATE_TASK = 81;
+    ClientProtocolErrorCodes.STALE_TASK = 82;
+    ClientProtocolErrorCodes.LOCAL_MEMBER_RESET = 83;
+    ClientProtocolErrorCodes.INDETERMINATE_OPERATION_STATE = 84;
+    ClientProtocolErrorCodes.FLAKE_ID_NODE_ID_OUT_OF_RANGE_EXCEPTION = 85;
+    ClientProtocolErrorCodes.TARGET_NOT_REPLICA_EXCEPTION = 86;
+    ClientProtocolErrorCodes.MUTATION_DISALLOWED_EXCEPTION = 87;
+    ClientProtocolErrorCodes.CONSISTENCY_LOST_EXCEPTION = 88;
+    return ClientProtocolErrorCodes;
+}());
+exports.ClientProtocolErrorCodes = ClientProtocolErrorCodes;

package/lib/protocol/ErrorCodec.d.ts

@@ -0,0 +1,11 @@
+import ClientMessage = require('../ClientMessage');
+import { StackTraceElementCodec } from './StackTraceElementCodec';
+export declare class ErrorCodec {
+    errorCode: number;
+    className: string;
+    message: string;
+    stackTrace: StackTraceElementCodec[];
+    causeErrorCode: number;
+    causeClassName: string;
+    static decode(clientMessage: ClientMessage): ErrorCodec;
+}

package/lib/protocol/ErrorCodec.js

@@ -0,0 +1,50 @@
+"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 StackTraceElementCodec_1 = require("./StackTraceElementCodec");
+var ErrorCodec = /** @class */ (function () {
+    function ErrorCodec() {
+        this.errorCode = null;
+        this.className = null;
+        this.message = null;
+        this.stackTrace = [];
+        this.causeErrorCode = null;
+        this.causeClassName = null;
+    }
+    ErrorCodec.decode = function (clientMessage) {
+        var exception = new ErrorCodec();
+        exception.errorCode = clientMessage.readInt32();
+        exception.className = clientMessage.readString();
+        var isMessageNull = clientMessage.readBoolean();
+        if (!isMessageNull) {
+            exception.message = clientMessage.readString();
+        }
+        var stackTraceDepth = clientMessage.readInt32();
+        exception.stackTrace = [];
+        for (var i = 0; i < stackTraceDepth; i++) {
+            exception.stackTrace.push(StackTraceElementCodec_1.StackTraceElementCodec.decode(clientMessage));
+        }
+        exception.causeErrorCode = clientMessage.readInt32();
+        var causeClassNameNull = clientMessage.readBoolean();
+        if (!causeClassNameNull) {
+            exception.causeClassName = clientMessage.readString();
+        }
+        return exception;
+    };
+    return ErrorCodec;
+}());
+exports.ErrorCodec = ErrorCodec;

package/lib/protocol/ErrorFactory.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+export declare class ClientErrorFactory {
+    private codeToErrorConstructor;
+    constructor();
+    createErrorFromClientMessage(clientMessage: ClientMessage): Error;
+    createError(errorCode: number, className: string, message: string, cause: Error): Error;
+    private register(code, errorFactory);
+}

package/lib/protocol/ErrorFactory.js

@@ -0,0 +1,92 @@
+"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 HazelcastError_1 = require("../HazelcastError");
+var ClientProtocolErrorCodes_1 = require("./ClientProtocolErrorCodes");
+var ErrorCodec_1 = require("./ErrorCodec");
+var ClientErrorFactory = /** @class */ (function () {
+    function ClientErrorFactory() {
+        this.codeToErrorConstructor = new Map();
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ARRAY_INDEX_OUT_OF_BOUNDS, function (m, c) { return new RangeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ARRAY_STORE, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.AUTHENTICATION, function (m, c) { return new HazelcastError_1.AuthenticationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CALLER_NOT_MEMBER, function (m, c) { return new HazelcastError_1.CallerNotMemberError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CANCELLATION, function (m, c) { return new HazelcastError_1.CancellationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CLASS_CAST, function (m, c) { return new HazelcastError_1.ClassCastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CLASS_NOT_FOUND, function (m, c) { return new HazelcastError_1.ClassNotFoundError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONCURRENT_MODIFICATION, function (m, c) { return new HazelcastError_1.ConcurrentModificationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONFIG_MISMATCH, function (m, c) { return new HazelcastError_1.ConfigMismatchError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONFIGURATION, function (m, c) { return new HazelcastError_1.ConfigurationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.DISTRIBUTED_OBJECT_DESTROYED, function (m, c) { return new HazelcastError_1.DistributedObjectDestroyedError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.DUPLICATE_INSTANCE_NAME, function (m, c) { return new HazelcastError_1.DuplicateInstanceNameError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.EOF, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST, function (m, c) { return new HazelcastError_1.HazelcastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST_INSTANCE_NOT_ACTIVE, function (m, c) { return new HazelcastError_1.HazelcastInstanceNotActiveError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST_OVERLOAD, function (m, c) { return new HazelcastError_1.HazelcastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST_SERIALIZATION, function (m, c) { return new HazelcastError_1.HazelcastSerializationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.IO, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ILLEGAL_ARGUMENT, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ILLEGAL_STATE, function (m, c) { return new HazelcastError_1.IllegalStateError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INDEX_OUT_OF_BOUNDS, function (m, c) { return new RangeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INTERRUPTED, function (m, c) { return new Error(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INVALID_ADDRESS, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INVALID_CONFIGURATION, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.MEMBER_LEFT, function (m, c) { return new HazelcastError_1.MemberLeftError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NEGATIVE_ARRAY_SIZE, function (m, c) { return new RangeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NO_SUCH_ELEMENT, function (m, c) { return new ReferenceError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NOT_SERIALIZABLE, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NULL_POINTER, function (m, c) { return new ReferenceError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.OPERATION_TIMEOUT, function (m, c) { return new HazelcastError_1.InvocationTimeoutError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.PARTITION_MIGRATING, function (m, c) { return new HazelcastError_1.PartitionMigratingError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.QUERY, function (m, c) { return new HazelcastError_1.QueryError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.QUERY_RESULT_SIZE_EXCEEDED, function (m, c) { return new HazelcastError_1.QueryError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.QUORUM, function (m, c) { return new HazelcastError_1.QuorumError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.RETRYABLE_HAZELCAST, function (m, c) { return new HazelcastError_1.RetryableHazelcastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.RETRYABLE_IO, function (m, c) { return new HazelcastError_1.RetryableIOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.SOCKET, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.STALE_SEQUENCE, function (m, c) { return new HazelcastError_1.StaleSequenceError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TARGET_DISCONNECTED, function (m, c) { return new HazelcastError_1.TargetDisconnectedError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TARGET_NOT_MEMBER, function (m, c) { return new HazelcastError_1.TargetNotMemberError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TOPIC_OVERLOAD, function (m, c) { return new HazelcastError_1.TopicOverloadError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TRANSACTION, function (m, c) { return new HazelcastError_1.TransactionError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TRANSACTION_NOT_ACTIVE, function (m, c) { return new HazelcastError_1.TransactionNotActiveError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TRANSACTION_TIMED_OUT, function (m, c) { return new HazelcastError_1.TransactionTimedOutError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.UNSUPPORTED_OPERATION, function (m, c) { return new HazelcastError_1.UnsupportedOperationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NO_DATA_MEMBER, function (m, c) { return new HazelcastError_1.NoDataMemberInClusterError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.STALE_TASK_ID, function (m, c) { return new HazelcastError_1.StaleTaskIdError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.FLAKE_ID_NODE_ID_OUT_OF_RANGE_EXCEPTION, function (m, c) { return new HazelcastError_1.NodeIdOutOfRangeError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONSISTENCY_LOST_EXCEPTION, function (m, c) { return new HazelcastError_1.ConsistencyLostError(m, c); });
+    }
+    ClientErrorFactory.prototype.createErrorFromClientMessage = function (clientMessage) {
+        var errorCodec = ErrorCodec_1.ErrorCodec.decode(clientMessage);
+        return this.createError(errorCodec.errorCode, errorCodec.className, errorCodec.message, null);
+    };
+    ClientErrorFactory.prototype.createError = function (errorCode, className, message, cause) {
+        var factoryFunc = this.codeToErrorConstructor.get(errorCode);
+        if (factoryFunc != null) {
+            return factoryFunc(message, cause);
+        }
+        else {
+            return new HazelcastError_1.UndefinedErrorCodeError(message, className);
+        }
+    };
+    ClientErrorFactory.prototype.register = function (code, errorFactory) {
+        this.codeToErrorConstructor.set(code, errorFactory);
+    };
+    return ClientErrorFactory;
+}());
+exports.ClientErrorFactory = ClientErrorFactory;

package/lib/protocol/StackTraceElementCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+export declare class StackTraceElementCodec {
+    declaringClass: string;
+    methodName: string;
+    fileName: string;
+    lineNumber: number;
+    static decode(payload: ClientMessage): StackTraceElementCodec;
+}

package/lib/protocol/StackTraceElementCodec.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 StackTraceElementCodec = /** @class */ (function () {
+    function StackTraceElementCodec() {
+        this.declaringClass = null;
+        this.methodName = null;
+        this.fileName = null;
+        this.lineNumber = null;
+    }
+    StackTraceElementCodec.decode = function (payload) {
+        var stackTraceElement = new StackTraceElementCodec();
+        stackTraceElement.declaringClass = payload.readString();
+        stackTraceElement.methodName = payload.readString();
+        var fileNameNull = payload.readBoolean();
+        if (!fileNameNull) {
+            stackTraceElement.fileName = payload.readString();
+        }
+        stackTraceElement.lineNumber = payload.readInt32();
+        return stackTraceElement;
+    };
+    return StackTraceElementCodec;
+}());
+exports.StackTraceElementCodec = StackTraceElementCodec;

package/lib/proxy/AtomicLongProxy.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="long" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { IAtomicLong } from './IAtomicLong';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+export declare class AtomicLongProxy extends PartitionSpecificProxy implements IAtomicLong {
+    addAndGet(delta: Long | number): Promise<Long>;
+    compareAndSet(expect: Long | number, update: Long | number): Promise<boolean>;
+    decrementAndGet(): Promise<Long>;
+    get(): Promise<Long>;
+    getAndAdd(delta: Long | number): Promise<Long>;
+    getAndSet(newValue: Long | number): Promise<Long>;
+    incrementAndGet(): Promise<Long>;
+    getAndIncrement(): Promise<Long>;
+    set(newValue: Long | number): Promise<void>;
+}

package/lib/proxy/AtomicLongProxy.js

@@ -0,0 +1,72 @@
+"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 AtomicLongAddAndGetCodec_1 = require("../codec/AtomicLongAddAndGetCodec");
+var AtomicLongCompareAndSetCodec_1 = require("../codec/AtomicLongCompareAndSetCodec");
+var AtomicLongDecrementAndGetCodec_1 = require("../codec/AtomicLongDecrementAndGetCodec");
+var AtomicLongGetAndAddCodec_1 = require("../codec/AtomicLongGetAndAddCodec");
+var AtomicLongGetAndIncrementCodec_1 = require("../codec/AtomicLongGetAndIncrementCodec");
+var AtomicLongGetAndSetCodec_1 = require("../codec/AtomicLongGetAndSetCodec");
+var AtomicLongGetCodec_1 = require("../codec/AtomicLongGetCodec");
+var AtomicLongIncrementAndGetCodec_1 = require("../codec/AtomicLongIncrementAndGetCodec");
+var AtomicLongSetCodec_1 = require("../codec/AtomicLongSetCodec");
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var AtomicLongProxy = /** @class */ (function (_super) {
+    __extends(AtomicLongProxy, _super);
+    function AtomicLongProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AtomicLongProxy.prototype.addAndGet = function (delta) {
+        return this.encodeInvoke(AtomicLongAddAndGetCodec_1.AtomicLongAddAndGetCodec, delta);
+    };
+    AtomicLongProxy.prototype.compareAndSet = function (expect, update) {
+        return this.encodeInvoke(AtomicLongCompareAndSetCodec_1.AtomicLongCompareAndSetCodec, expect, update);
+    };
+    AtomicLongProxy.prototype.decrementAndGet = function () {
+        return this.encodeInvoke(AtomicLongDecrementAndGetCodec_1.AtomicLongDecrementAndGetCodec);
+    };
+    AtomicLongProxy.prototype.get = function () {
+        return this.encodeInvoke(AtomicLongGetCodec_1.AtomicLongGetCodec);
+    };
+    AtomicLongProxy.prototype.getAndAdd = function (delta) {
+        return this.encodeInvoke(AtomicLongGetAndAddCodec_1.AtomicLongGetAndAddCodec, delta);
+    };
+    AtomicLongProxy.prototype.getAndSet = function (newValue) {
+        return this.encodeInvoke(AtomicLongGetAndSetCodec_1.AtomicLongGetAndSetCodec, newValue);
+    };
+    AtomicLongProxy.prototype.incrementAndGet = function () {
+        return this.encodeInvoke(AtomicLongIncrementAndGetCodec_1.AtomicLongIncrementAndGetCodec);
+    };
+    AtomicLongProxy.prototype.getAndIncrement = function () {
+        return this.encodeInvoke(AtomicLongGetAndIncrementCodec_1.AtomicLongGetAndIncrementCodec);
+    };
+    AtomicLongProxy.prototype.set = function (newValue) {
+        return this.encodeInvoke(AtomicLongSetCodec_1.AtomicLongSetCodec, newValue);
+    };
+    return AtomicLongProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.AtomicLongProxy = AtomicLongProxy;

package/lib/proxy/BaseProxy.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import HazelcastClient from '../HazelcastClient';
+import { Data } from '../serialization/Data';
+import Address = require('../Address');
+/**
+ * Common super class for any proxy.
+ */
+export declare class BaseProxy {
+    protected client: HazelcastClient;
+    protected name: string;
+    protected serviceName: string;
+    constructor(client: HazelcastClient, serviceName: string, name: string);
+    getPartitionKey(): string;
+    /**
+     * Returns name of the proxy.
+     * @returns
+     */
+    getName(): string;
+    /**
+     * Returns name of the service which this proxy belongs to.
+     * Refer to service field of {@link ProxyManager} for service names.
+     * @returns
+     */
+    getServiceName(): string;
+    /**
+     * Deletes the proxy object and frees allocated resources on cluster.
+     * @returns
+     */
+    destroy(): Promise<void>;
+    protected postDestroy(): Promise<void>;
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given key.
+     * @param codec
+     * @param partitionKey
+     * @param codecArguments
+     * @returns
+     */
+    protected encodeInvokeOnKey<T>(codec: any, partitionKey: any, ...codecArguments: any[]): Promise<T>;
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given key.
+     * This method also overrides invocation timeout.
+     * @param timeoutMillis
+     * @param codec
+     * @param partitionKey
+     * @param codecArguments
+     * @returns
+     */
+    protected encodeInvokeOnKeyWithTimeout<T>(timeoutMillis: number, codec: any, partitionKey: any, ...codecArguments: any[]): Promise<T>;
+    /**
+     * Encodes a request from a codec and invokes it on any node.
+     * @param codec
+     * @param codecArguments
+     * @returns
+     */
+    protected encodeInvokeOnRandomTarget<T>(codec: any, ...codecArguments: any[]): Promise<T>;
+    protected encodeInvokeOnAddress<T>(codec: any, address: Address, ...codecArguments: any[]): Promise<T>;
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given partition.
+     * @param codec
+     * @param partitionId
+     * @param codecArguments
+     * @returns
+     */
+    protected encodeInvokeOnPartition<T>(codec: any, partitionId: number, ...codecArguments: any[]): Promise<T>;
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given partition.
+     * This method also overrides invocation timeout.
+     * @param codec
+     * @param partitionId
+     * @param codecArguments
+     * @returns
+     */
+    protected encodeInvokeOnPartitionWithTimeout<T>(timeoutMillis: number, codec: any, partitionId: number, ...codecArguments: any[]): Promise<T>;
+    /**
+     * Serializes an object according to serialization settings of the client.
+     * @param object
+     * @returns
+     */
+    protected toData(object: any): Data;
+    /**
+     * De-serializes an object from binary form according to serialization settings of the client.
+     * @param data
+     * @returns {any}
+     */
+    protected toObject(data: Data): any;
+    protected getConnectedServerVersion(): number;
+    private createPromise<T>(codec, promise);
+}