@celerispay/hazelcast-client 3.12.5

package/lib/serialization/SerializationService.d.ts

@@ -0,0 +1,60 @@
+import { SerializationConfig } from '../config/SerializationConfig';
+import { Data, DataInput, DataOutput } from './Data';
+import HazelcastClient from '../HazelcastClient';
+export interface SerializationService {
+    toData(object: any, paritioningStrategy?: any): Data;
+    toObject(data: Data): any;
+    writeObject(out: DataOutput, object: any): void;
+    readObject(inp: DataInput): any;
+}
+export interface Serializer {
+    getId(): number;
+    read(input: DataInput): any;
+    write(output: DataOutput, object: any): void;
+}
+export declare class SerializationServiceV1 implements SerializationService {
+    private registry;
+    private serializerNameToId;
+    private numberType;
+    private serializationConfig;
+    private isStandardUTF;
+    private client;
+    constructor(client: HazelcastClient, serializationConfig: SerializationConfig);
+    isData(object: any): boolean;
+    toData(object: any, partitioningStrategy?: any): Data;
+    toObject(data: Data): any;
+    writeObject(out: DataOutput, object: any): void;
+    readObject(inp: DataInput): any;
+    registerSerializer(name: string, serializer: Serializer): void;
+    /**
+     * Serialization precedence
+     *  1. NULL
+     *  2. DataSerializable
+     *  3. Portable
+     *  4. Default Types
+     *      * Byte, Boolean, Character, Short, Integer, Long, Float, Double, String
+     *      * Array of [Byte, Boolean, Character, Short, Integer, Long, Float, Double, String]
+     *      * Java types [Date, BigInteger, BigDecimal, Class, Enum]
+     *  5. Custom serializers
+     *  6. Global Serializer
+     *  7. Fallback (JSON)
+     * @param obj
+     * @returns
+     */
+    findSerializerFor(obj: any): Serializer;
+    protected lookupDefaultSerializer(obj: any): Serializer;
+    protected lookupCustomSerializer(obj: any): Serializer;
+    protected lookupGlobalSerializer(): Serializer;
+    protected isIdentifiedDataSerializable(obj: any): boolean;
+    protected isPortableSerializable(obj: any): boolean;
+    protected registerDefaultSerializers(): void;
+    protected registerIdentifiedFactories(): void;
+    protected registerCustomSerializers(): void;
+    protected registerGlobalSerializer(): void;
+    protected assertValidCustomSerializer(candidate: any): void;
+    protected isCustomSerializable(object: any): boolean;
+    protected findSerializerByName(name: string, isArray: boolean): Serializer;
+    protected findSerializerById(id: number): Serializer;
+    protected calculatePartitionHash(object: any, strategy: Function): number;
+    private defaultPartitionStrategy(obj);
+}

package/lib/serialization/SerializationService.js

@@ -0,0 +1,312 @@
+"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 AggregatorFactory_1 = require("../aggregation/AggregatorFactory");
+var ClusterDataFactory_1 = require("../ClusterDataFactory");
+var ClusterDataFactoryHelper_1 = require("../ClusterDataFactoryHelper");
+var ReliableTopicMessage_1 = require("../proxy/topic/ReliableTopicMessage");
+var Util = require("../Util");
+var DefaultPredicates = require("./DefaultPredicates");
+var DefaultSerializer_1 = require("./DefaultSerializer");
+var HeapData_1 = require("./HeapData");
+var ObjectData_1 = require("./ObjectData");
+var PortableSerializer_1 = require("./portable/PortableSerializer");
+var PredicateFactory_1 = require("./PredicateFactory");
+var JsonStringDeserializationPolicy_1 = require("../config/JsonStringDeserializationPolicy");
+var StringSerializationPolicy_1 = require("../config/StringSerializationPolicy");
+var RestValue_1 = require("../core/RestValue");
+var SerializationServiceV1 = /** @class */ (function () {
+    function SerializationServiceV1(client, serializationConfig) {
+        this.client = client;
+        this.serializationConfig = serializationConfig;
+        this.isStandardUTF = this.serializationConfig.stringSerializationPolicy === StringSerializationPolicy_1.StringSerializationPolicy.STANDARD;
+        this.registry = {};
+        this.serializerNameToId = {};
+        this.registerDefaultSerializers();
+        this.registerCustomSerializers();
+        this.registerGlobalSerializer();
+    }
+    SerializationServiceV1.prototype.isData = function (object) {
+        if (object instanceof HeapData_1.HeapData) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    SerializationServiceV1.prototype.toData = function (object, partitioningStrategy) {
+        if (partitioningStrategy === void 0) { partitioningStrategy = this.defaultPartitionStrategy; }
+        if (this.isData(object)) {
+            return object;
+        }
+        var dataOutput = new ObjectData_1.PositionalObjectDataOutput(this, this.serializationConfig.isBigEndian, this.isStandardUTF);
+        var serializer = this.findSerializerFor(object);
+        // Check if object is partition aware
+        if (object != null && object.getPartitionKey) {
+            var partitionKey = object.getPartitionKey();
+            var serializedPartitionKey = this.toData(partitionKey);
+            dataOutput.writeIntBE(this.calculatePartitionHash(serializedPartitionKey, partitioningStrategy));
+        }
+        else {
+            dataOutput.writeIntBE(this.calculatePartitionHash(object, partitioningStrategy));
+        }
+        dataOutput.writeIntBE(serializer.getId());
+        serializer.write(dataOutput, object);
+        return new HeapData_1.HeapData(dataOutput.toBuffer());
+    };
+    SerializationServiceV1.prototype.toObject = function (data) {
+        if (data == null) {
+            return data;
+        }
+        if (!data.getType) {
+            return data;
+        }
+        var serializer = this.findSerializerById(data.getType());
+        var dataInput = new ObjectData_1.ObjectDataInput(data.toBuffer(), HeapData_1.DATA_OFFSET, this, this.serializationConfig.isBigEndian, this.isStandardUTF);
+        return serializer.read(dataInput);
+    };
+    SerializationServiceV1.prototype.writeObject = function (out, object) {
+        var serializer = this.findSerializerFor(object);
+        out.writeInt(serializer.getId());
+        serializer.write(out, object);
+    };
+    SerializationServiceV1.prototype.readObject = function (inp) {
+        var serializerId = inp.readInt();
+        var serializer = this.findSerializerById(serializerId);
+        return serializer.read(inp);
+    };
+    SerializationServiceV1.prototype.registerSerializer = function (name, serializer) {
+        if (this.serializerNameToId[name]) {
+            throw new RangeError('Given serializer name is already in the registry.');
+        }
+        if (this.registry[serializer.getId()]) {
+            throw new RangeError('Given serializer id is already in the registry.');
+        }
+        this.serializerNameToId[name] = serializer.getId();
+        this.registry[serializer.getId()] = serializer;
+    };
+    /**
+     * Serialization precedence
+     *  1. NULL
+     *  2. DataSerializable
+     *  3. Portable
+     *  4. Default Types
+     *      * Byte, Boolean, Character, Short, Integer, Long, Float, Double, String
+     *      * Array of [Byte, Boolean, Character, Short, Integer, Long, Float, Double, String]
+     *      * Java types [Date, BigInteger, BigDecimal, Class, Enum]
+     *  5. Custom serializers
+     *  6. Global Serializer
+     *  7. Fallback (JSON)
+     * @param obj
+     * @returns
+     */
+    SerializationServiceV1.prototype.findSerializerFor = function (obj) {
+        if (obj === undefined) {
+            throw new RangeError('undefined cannot be serialized.');
+        }
+        var serializer = null;
+        if (obj === null) {
+            serializer = this.findSerializerByName('null', false);
+        }
+        if (serializer === null) {
+            serializer = this.lookupDefaultSerializer(obj);
+        }
+        if (serializer === null) {
+            serializer = this.lookupCustomSerializer(obj);
+        }
+        if (serializer === null) {
+            serializer = this.lookupGlobalSerializer();
+        }
+        if (serializer === null) {
+            serializer = this.findSerializerByName('!json', false);
+        }
+        if (serializer === null) {
+            throw new RangeError('There is no suitable serializer for ' + obj + '.');
+        }
+        return serializer;
+    };
+    SerializationServiceV1.prototype.lookupDefaultSerializer = function (obj) {
+        var serializer = null;
+        if (this.isIdentifiedDataSerializable(obj)) {
+            return this.findSerializerByName('identified', false);
+        }
+        if (this.isPortableSerializable(obj)) {
+            return this.findSerializerByName('!portable', false);
+        }
+        var objectType = Util.getType(obj);
+        if (objectType === 'array') {
+            if (obj.length === 0) {
+                serializer = this.findSerializerByName('number', true);
+            }
+            else {
+                serializer = this.findSerializerByName(Util.getType(obj[0]), true);
+            }
+        }
+        else {
+            serializer = this.findSerializerByName(objectType, false);
+        }
+        return serializer;
+    };
+    SerializationServiceV1.prototype.lookupCustomSerializer = function (obj) {
+        if (this.isCustomSerializable(obj)) {
+            return this.findSerializerById(obj.hzGetCustomId());
+        }
+        return null;
+    };
+    SerializationServiceV1.prototype.lookupGlobalSerializer = function () {
+        return this.findSerializerByName('!global', false);
+    };
+    SerializationServiceV1.prototype.isIdentifiedDataSerializable = function (obj) {
+        return (obj.readData && obj.writeData && obj.getClassId && obj.getFactoryId);
+    };
+    SerializationServiceV1.prototype.isPortableSerializable = function (obj) {
+        return (obj.readPortable && obj.writePortable && obj.getFactoryId && obj.getClassId);
+    };
+    SerializationServiceV1.prototype.registerDefaultSerializers = function () {
+        this.registerSerializer('string', new DefaultSerializer_1.StringSerializer());
+        this.registerSerializer('double', new DefaultSerializer_1.DoubleSerializer());
+        this.registerSerializer('byte', new DefaultSerializer_1.ByteSerializer());
+        this.registerSerializer('boolean', new DefaultSerializer_1.BooleanSerializer());
+        this.registerSerializer('null', new DefaultSerializer_1.NullSerializer());
+        this.registerSerializer('short', new DefaultSerializer_1.ShortSerializer());
+        this.registerSerializer('integer', new DefaultSerializer_1.IntegerSerializer());
+        this.registerSerializer('long', new DefaultSerializer_1.LongSerializer());
+        this.registerSerializer('float', new DefaultSerializer_1.FloatSerializer());
+        this.registerSerializer('char', new DefaultSerializer_1.CharSerializer());
+        this.registerSerializer('date', new DefaultSerializer_1.DateSerializer());
+        this.registerSerializer('byteArray', new DefaultSerializer_1.ByteArraySerializer());
+        this.registerSerializer('charArray', new DefaultSerializer_1.CharArraySerializer());
+        this.registerSerializer('booleanArray', new DefaultSerializer_1.BooleanArraySerializer());
+        this.registerSerializer('shortArray', new DefaultSerializer_1.ShortArraySerializer());
+        this.registerSerializer('integerArray', new DefaultSerializer_1.IntegerArraySerializer());
+        this.registerSerializer('longArray', new DefaultSerializer_1.LongArraySerializer());
+        this.registerSerializer('doubleArray', new DefaultSerializer_1.DoubleArraySerializer());
+        this.registerSerializer('stringArray', new DefaultSerializer_1.StringArraySerializer());
+        this.registerSerializer('javaClass', new DefaultSerializer_1.JavaClassSerializer());
+        this.registerSerializer('floatArray', new DefaultSerializer_1.FloatArraySerializer());
+        this.registerIdentifiedFactories();
+        this.registerSerializer('!portable', new PortableSerializer_1.PortableSerializer(this, this.serializationConfig));
+        if (this.serializationConfig.jsonStringDeserializationPolicy === JsonStringDeserializationPolicy_1.JsonStringDeserializationPolicy.EAGER) {
+            this.registerSerializer('!json', new DefaultSerializer_1.JsonSerializer());
+        }
+        else {
+            this.registerSerializer('!json', new DefaultSerializer_1.HazelcastJsonValueSerializer());
+        }
+    };
+    SerializationServiceV1.prototype.registerIdentifiedFactories = function () {
+        var factories = {};
+        for (var id in this.serializationConfig.dataSerializableFactories) {
+            factories[id] = this.serializationConfig.dataSerializableFactories[id];
+        }
+        var factoryConfigs = this.serializationConfig.dataSerializableFactoryConfigs;
+        for (var id in factoryConfigs) {
+            var path = factoryConfigs[id].path;
+            var exportedName = factoryConfigs[id].exportedName;
+            var factoryConstructor = Util.loadNameFromPath(path, exportedName);
+            factories[id] = new factoryConstructor();
+        }
+        factories[PredicateFactory_1.PREDICATE_FACTORY_ID] = new PredicateFactory_1.PredicateFactory(DefaultPredicates);
+        factories[ReliableTopicMessage_1.RELIABLE_TOPIC_MESSAGE_FACTORY_ID] = new ReliableTopicMessage_1.ReliableTopicMessageFactory();
+        factories[ClusterDataFactoryHelper_1.ClusterDataFactoryHelper.FACTORY_ID] = new ClusterDataFactory_1.ClusterDataFactory();
+        factories[AggregatorFactory_1.AggregatorFactory.FACTORY_ID] = new AggregatorFactory_1.AggregatorFactory();
+        factories[RestValue_1.REST_VALUE_FACTORY_ID] = new RestValue_1.RestValueFactory();
+        this.registerSerializer('identified', new DefaultSerializer_1.IdentifiedDataSerializableSerializer(factories));
+    };
+    SerializationServiceV1.prototype.registerCustomSerializers = function () {
+        var customSerializersArray = this.serializationConfig.customSerializers;
+        var self = this;
+        customSerializersArray.forEach(function (candidate) {
+            self.assertValidCustomSerializer(candidate);
+            self.registerSerializer('!custom' + candidate.getId(), candidate);
+        });
+        var customSerializerConfigs = this.serializationConfig.customSerializerConfigs;
+        for (var typeId in customSerializerConfigs) {
+            var serializerConfig = customSerializerConfigs[typeId];
+            var customSerializer = new (Util.loadNameFromPath(serializerConfig.path, serializerConfig.exportedName))();
+            this.registerSerializer('!custom' + typeId, customSerializer);
+        }
+    };
+    SerializationServiceV1.prototype.registerGlobalSerializer = function () {
+        var candidate = null;
+        if (this.serializationConfig.globalSerializerConfig != null) {
+            var exportedName = this.serializationConfig.globalSerializerConfig.exportedName;
+            var path = this.serializationConfig.globalSerializerConfig.path;
+            var serializerFactory = Util.loadNameFromPath(path, exportedName);
+            candidate = new serializerFactory();
+        }
+        if (candidate == null) {
+            candidate = this.serializationConfig.globalSerializer;
+        }
+        if (candidate == null) {
+            return;
+        }
+        this.assertValidCustomSerializer(candidate);
+        this.registerSerializer('!global', candidate);
+    };
+    SerializationServiceV1.prototype.assertValidCustomSerializer = function (candidate) {
+        var fGetId = 'getId';
+        var fRead = 'read';
+        var fWrite = 'write';
+        if (typeof candidate[fGetId] !== 'function' ||
+            typeof candidate[fRead] !== 'function' ||
+            typeof candidate[fWrite] !== 'function') {
+            throw new TypeError('Custom serializer should have ' + fGetId + ', ' + fRead + ' and ' + fWrite + ' methods.');
+        }
+        var typeId = candidate[fGetId]();
+        if (!Number.isInteger(typeId) || typeId < 1) {
+            throw new TypeError('Custom serializer should have its typeId greater than or equal to 1.');
+        }
+    };
+    SerializationServiceV1.prototype.isCustomSerializable = function (object) {
+        var prop = 'hzGetCustomId';
+        return (object[prop] && typeof object[prop] === 'function' && object[prop]() >= 1);
+    };
+    SerializationServiceV1.prototype.findSerializerByName = function (name, isArray) {
+        var convertedName;
+        if (name === 'number') {
+            convertedName = this.serializationConfig.defaultNumberType;
+        }
+        else {
+            convertedName = name;
+        }
+        var serializerName = convertedName + (isArray ? 'Array' : '');
+        var serializerId = this.serializerNameToId[serializerName];
+        if (serializerId == null) {
+            return null;
+        }
+        return this.findSerializerById(serializerId);
+    };
+    SerializationServiceV1.prototype.findSerializerById = function (id) {
+        var serializer = this.registry[id];
+        return serializer;
+    };
+    SerializationServiceV1.prototype.calculatePartitionHash = function (object, strategy) {
+        return strategy(object);
+    };
+    SerializationServiceV1.prototype.defaultPartitionStrategy = function (obj) {
+        /* tslint:disable:no-string-literal */
+        if (obj == null || !obj['getPartitionHash']) {
+            /* tslint:enable:no-string-literal */
+            return 0;
+        }
+        else {
+            return obj.getPartitionHash();
+        }
+    };
+    return SerializationServiceV1;
+}());
+exports.SerializationServiceV1 = SerializationServiceV1;

package/lib/serialization/SerializationUtil.d.ts

@@ -0,0 +1,3 @@
+import { Data } from './Data';
+export declare function deserializeEntryList<K, V>(toObject: Function, entrySet: Array<[Data, Data]>): Array<[K, V]>;
+export declare function serializeList(toData: Function, input: any[]): Data[];

package/lib/serialization/SerializationUtil.js

@@ -0,0 +1,31 @@
+"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 });
+function deserializeEntryList(toObject, entrySet) {
+    var deserializedSet = [];
+    entrySet.forEach(function (entry) {
+        deserializedSet.push([toObject(entry[0]), toObject(entry[1])]);
+    });
+    return deserializedSet;
+}
+exports.deserializeEntryList = deserializeEntryList;
+function serializeList(toData, input) {
+    return input.map(function (each) {
+        return toData(each);
+    });
+}
+exports.serializeList = serializeList;

package/lib/serialization/portable/ClassDefinition.d.ts

@@ -0,0 +1,54 @@
+export declare class ClassDefinition {
+    private factoryId;
+    private classId;
+    private version;
+    private fields;
+    constructor(factoryId: number, classId: number, version: number);
+    addFieldDefinition(definition: FieldDefinition): void;
+    getFieldCount(): number;
+    getFactoryId(): number;
+    getClassId(): number;
+    getVersion(): number;
+    getFieldType(name: string): FieldType;
+    hasField(name: string): boolean;
+    getField(name: string): FieldDefinition;
+    getFieldById(index: number): FieldDefinition;
+    equals(o: ClassDefinition): boolean;
+}
+export declare class FieldDefinition {
+    private readonly index;
+    private readonly fieldName;
+    private readonly type;
+    private readonly factoryId;
+    private readonly classId;
+    private readonly version;
+    constructor(index: number, fieldName: string, type: FieldType, version: number, factoryId?: number, classId?: number);
+    getType(): FieldType;
+    getName(): string;
+    getIndex(): number;
+    getClassId(): number;
+    getFactoryId(): number;
+    getVersion(): number;
+}
+export declare enum FieldType {
+    PORTABLE = 0,
+    BYTE = 1,
+    BOOLEAN = 2,
+    CHAR = 3,
+    SHORT = 4,
+    INT = 5,
+    LONG = 6,
+    FLOAT = 7,
+    DOUBLE = 8,
+    UTF = 9,
+    PORTABLE_ARRAY = 10,
+    BYTE_ARRAY = 11,
+    BOOLEAN_ARRAY = 12,
+    CHAR_ARRAY = 13,
+    SHORT_ARRAY = 14,
+    INT_ARRAY = 15,
+    LONG_ARRAY = 16,
+    FLOAT_ARRAY = 17,
+    DOUBLE_ARRAY = 18,
+    UTF_ARRAY = 19,
+}

package/lib/serialization/portable/ClassDefinition.js

@@ -0,0 +1,140 @@
+"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 assert_1 = require("assert");
+var ClassDefinition = /** @class */ (function () {
+    function ClassDefinition(factoryId, classId, version) {
+        this.fields = {};
+        this.factoryId = factoryId;
+        this.classId = classId;
+        this.version = version;
+    }
+    ClassDefinition.prototype.addFieldDefinition = function (definition) {
+        this.fields[definition.getName()] = definition;
+    };
+    ClassDefinition.prototype.getFieldCount = function () {
+        return Object.keys(this.fields).length;
+    };
+    ClassDefinition.prototype.getFactoryId = function () {
+        return this.factoryId;
+    };
+    ClassDefinition.prototype.getClassId = function () {
+        return this.classId;
+    };
+    ClassDefinition.prototype.getVersion = function () {
+        return this.version;
+    };
+    ClassDefinition.prototype.getFieldType = function (name) {
+        var field = this.fields[name];
+        if (field != null) {
+            return field.getType();
+        }
+        else {
+            throw new RangeError("Field " + field + " does not exist.");
+        }
+    };
+    ClassDefinition.prototype.hasField = function (name) {
+        return this.fields[name] != null;
+    };
+    ClassDefinition.prototype.getField = function (name) {
+        var field = this.fields[name];
+        return field || null;
+    };
+    ClassDefinition.prototype.getFieldById = function (index) {
+        if (!Number.isInteger(index) || index < 0 || index >= this.getFieldCount()) {
+            throw new RangeError("Index: " + index + ", fields count: " + this.getFieldCount() + ".");
+        }
+        for (var fieldName in this.fields) {
+            if (this.fields[fieldName].getIndex() === index) {
+                return this.fields[fieldName];
+            }
+        }
+        throw new RangeError("There is no field with index " + index);
+    };
+    ClassDefinition.prototype.equals = function (o) {
+        if (!(o instanceof ClassDefinition)) {
+            return false;
+        }
+        if (o.factoryId !== this.factoryId || o.classId !== this.classId || o.version !== this.version) {
+            return false;
+        }
+        try {
+            assert_1.deepEqual(o.fields, this.fields);
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    };
+    return ClassDefinition;
+}());
+exports.ClassDefinition = ClassDefinition;
+var FieldDefinition = /** @class */ (function () {
+    function FieldDefinition(index, fieldName, type, version, factoryId, classId) {
+        if (factoryId === void 0) { factoryId = 0; }
+        if (classId === void 0) { classId = 0; }
+        this.index = index;
+        this.fieldName = fieldName;
+        this.type = type;
+        this.factoryId = factoryId;
+        this.classId = classId;
+        this.version = version;
+    }
+    FieldDefinition.prototype.getType = function () {
+        return this.type;
+    };
+    FieldDefinition.prototype.getName = function () {
+        return this.fieldName;
+    };
+    FieldDefinition.prototype.getIndex = function () {
+        return this.index;
+    };
+    FieldDefinition.prototype.getClassId = function () {
+        return this.classId;
+    };
+    FieldDefinition.prototype.getFactoryId = function () {
+        return this.factoryId;
+    };
+    FieldDefinition.prototype.getVersion = function () {
+        return this.version;
+    };
+    return FieldDefinition;
+}());
+exports.FieldDefinition = FieldDefinition;
+var FieldType;
+(function (FieldType) {
+    FieldType[FieldType["PORTABLE"] = 0] = "PORTABLE";
+    FieldType[FieldType["BYTE"] = 1] = "BYTE";
+    FieldType[FieldType["BOOLEAN"] = 2] = "BOOLEAN";
+    FieldType[FieldType["CHAR"] = 3] = "CHAR";
+    FieldType[FieldType["SHORT"] = 4] = "SHORT";
+    FieldType[FieldType["INT"] = 5] = "INT";
+    FieldType[FieldType["LONG"] = 6] = "LONG";
+    FieldType[FieldType["FLOAT"] = 7] = "FLOAT";
+    FieldType[FieldType["DOUBLE"] = 8] = "DOUBLE";
+    FieldType[FieldType["UTF"] = 9] = "UTF";
+    FieldType[FieldType["PORTABLE_ARRAY"] = 10] = "PORTABLE_ARRAY";
+    FieldType[FieldType["BYTE_ARRAY"] = 11] = "BYTE_ARRAY";
+    FieldType[FieldType["BOOLEAN_ARRAY"] = 12] = "BOOLEAN_ARRAY";
+    FieldType[FieldType["CHAR_ARRAY"] = 13] = "CHAR_ARRAY";
+    FieldType[FieldType["SHORT_ARRAY"] = 14] = "SHORT_ARRAY";
+    FieldType[FieldType["INT_ARRAY"] = 15] = "INT_ARRAY";
+    FieldType[FieldType["LONG_ARRAY"] = 16] = "LONG_ARRAY";
+    FieldType[FieldType["FLOAT_ARRAY"] = 17] = "FLOAT_ARRAY";
+    FieldType[FieldType["DOUBLE_ARRAY"] = 18] = "DOUBLE_ARRAY";
+    FieldType[FieldType["UTF_ARRAY"] = 19] = "UTF_ARRAY";
+})(FieldType = exports.FieldType || (exports.FieldType = {}));

package/lib/serialization/portable/ClassDefinitionBuilder.d.ts

@@ -0,0 +1,35 @@
+import { ClassDefinition, FieldDefinition } from './ClassDefinition';
+export declare class ClassDefinitionBuilder {
+    private readonly factoryId;
+    private readonly classId;
+    private readonly version;
+    private fieldDefinitions;
+    private index;
+    private done;
+    constructor(factoryId: number, classId: number, version?: number);
+    getFactoryId(): number;
+    getClassId(): number;
+    getVersion(): number;
+    addByteField(fieldName: string): ClassDefinitionBuilder;
+    addBooleanField(fieldName: string): ClassDefinitionBuilder;
+    addCharField(fieldName: string): ClassDefinitionBuilder;
+    addShortField(fieldName: string): ClassDefinitionBuilder;
+    addIntField(fieldName: string): ClassDefinitionBuilder;
+    addLongField(fieldName: string): ClassDefinitionBuilder;
+    addFloatField(fieldName: string): ClassDefinitionBuilder;
+    addDoubleField(fieldName: string): ClassDefinitionBuilder;
+    addUTFField(fieldName: string): ClassDefinitionBuilder;
+    addPortableField(fieldName: string, def: ClassDefinition): ClassDefinitionBuilder;
+    addByteArrayField(fieldName: string): ClassDefinitionBuilder;
+    addBooleanArrayField(fieldName: string): ClassDefinitionBuilder;
+    addCharArrayField(fieldName: string): ClassDefinitionBuilder;
+    addShortArrayField(fieldName: string): ClassDefinitionBuilder;
+    addIntArrayField(fieldName: string): ClassDefinitionBuilder;
+    addLongArrayField(fieldName: string): ClassDefinitionBuilder;
+    addFloatArrayField(fieldName: string): ClassDefinitionBuilder;
+    addDoubleArrayField(fieldName: string): ClassDefinitionBuilder;
+    addUTFArrayField(fieldName: string): ClassDefinitionBuilder;
+    addPortableArrayField(fieldName: string, def: ClassDefinition): ClassDefinitionBuilder;
+    addField(fieldDefinition: FieldDefinition): ClassDefinitionBuilder;
+    build(): ClassDefinition;
+}