@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/contracts/base/culture-sensitive-property.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CultureSensitiveProperty = void 0;
+const dirty_value_calculator_1 = __importDefault(require("../../dirty-value-calculator"));
+const guard_1 = __importDefault(require("../../guard"));
+const property_1 = require("./property");
+class CultureSensitiveProperty extends property_1.PropertyBase {
+    constructor(name, typeInfo, loadedCultures, values) {
+        super(name, typeInfo);
+        this._dirtyValueCalculators = {};
+        guard_1.default.arrayNotEmpty(loadedCultures);
+        loadedCultures.forEach(guard_1.default.notInvariantCulture);
+        this.isMultiLanguage = true;
+        this._values = {};
+        this._loadedCultures = [...new Set(loadedCultures)];
+        if (values !== undefined) {
+            guard_1.default.notNull(values);
+            Object.keys(values).forEach((culture) => {
+                this._values[culture] = values[culture]; //? Deep copy?
+            });
+        }
+    }
+    get isDirty() {
+        if (!this.isTracking) {
+            return false;
+        }
+        for (const cultureString in this._values) {
+            const culture = cultureString;
+            const value = this._values[culture];
+            const isDirty = this._dirtyValueCalculators[culture].isDirty(value);
+            if (isDirty) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getTypeName() {
+        return this.constructor.name;
+    }
+    getValue(culture) {
+        this.cultureMustBeLoaded(culture);
+        if (this._values[culture] != null) {
+            return this._values[culture]; //? Add 'casting' wrapper
+        }
+        return null; //? Allow undefined?
+    }
+    getValues(cultures) {
+        if (cultures !== undefined) {
+            guard_1.default.arrayNotEmpty(cultures);
+            this.culturesMustBeLoaded(cultures);
+            return cultures.reduce((values, culture) => {
+                values[culture] = this._values[culture]; //? Add 'casting' wrapper?
+                return values;
+            }, {});
+        }
+        else {
+            return this._loadedCultures.reduce((values, culture) => {
+                values[culture] = this._values[culture]; //? Add 'casting' wrapper?
+                return values;
+            }, {});
+        }
+    }
+    getCultures() {
+        return Object.keys(this._values);
+    }
+    setValue(culture, value) {
+        guard_1.default.notInvariantCulture(culture);
+        this.cultureMustBeLoaded(culture);
+        this._values[culture] = value;
+    }
+    startTracking() {
+        if (this.isTracking) {
+            return;
+        }
+        this.isTracking = true;
+        for (const culture of this._loadedCultures) {
+            const dirtyValueCalculator = new dirty_value_calculator_1.default();
+            dirtyValueCalculator.setOriginalValue(this._values[culture]);
+            this._dirtyValueCalculators[culture] = dirtyValueCalculator;
+        }
+    }
+    markClean() {
+        if (!this.isTracking) {
+            return;
+        }
+        for (const culture of this._loadedCultures) {
+            this._dirtyValueCalculators[culture].setOriginalValue(this._values[culture]);
+        }
+    }
+    getDirtyCultures() {
+        if (!this.isTracking) {
+            throw new Error("Can't get dirty cultures when not tracking changes.");
+        }
+        return this._loadedCultures.reduce((dirtyCultures, culture) => {
+            if (this._dirtyValueCalculators[culture].isDirty(this._values[culture])) {
+                dirtyCultures.push(culture);
+            }
+            return dirtyCultures;
+        }, []);
+    }
+    cultureMustBeLoaded(culture) {
+        if (!this._loadedCultures.includes(culture)) {
+            throw new Error(`Culture ${culture} was not loaded.`);
+        }
+    }
+    culturesMustBeLoaded(cultures) {
+        cultures.forEach(culture => this.cultureMustBeLoaded(culture));
+    }
+}
+exports.CultureSensitiveProperty = CultureSensitiveProperty;

package/dist/contracts/base/data-type.d.ts

@@ -0,0 +1,18 @@
+import { Moment } from "moment";
+import { JsonValue, MapCultureTo, Nullable, UnionKeyToValue } from "../../base-types";
+declare type DataType = "Relation" | "String" | "Integer" | "Long" | "Decimal" | "Boolean" | "DateTime" | "DateTimeOffset" | "Json";
+declare type PropertyDataType = Exclude<DataType, "Relation">;
+declare type RelationDataType = Exclude<DataType, PropertyDataType>;
+declare const PropertyDataType: UnionKeyToValue<PropertyDataType>;
+declare const DataType: UnionKeyToValue<DataType>;
+export { PropertyDataType, RelationDataType };
+export declare class TypeInfo<T extends PropertyDataType | unknown = PropertyDataType, B extends boolean = boolean> {
+    name: string;
+    type: T;
+    readonly isArray: B;
+    constructor(type_: T, isArray?: B);
+}
+export declare type PropertyValue<T extends PropertyDataType | unknown = unknown, B extends boolean = false> = B extends true ? Nullable<Array<Type<T>>> : Nullable<Type<T>>;
+export declare type PropertyValuePerCulture<T extends PropertyDataType | unknown = unknown, B extends boolean = false> = MapCultureTo<PropertyValue<T, B>>;
+export declare type Type<T extends PropertyDataType | unknown> = T extends "String" ? string : T extends "Integer" ? number : T extends "Long" ? number : T extends "Decimal" ? number : T extends "Boolean" ? boolean : T extends "DateTime" ? Date | Moment : T extends "DateTimeOffset" ? Date | Moment : T extends "Json" ? JsonValue : T extends unknown ? unknown : never;
+export default DataType;

package/dist/contracts/base/data-type.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeInfo = exports.PropertyDataType = void 0;
+const PropertyDataType = {
+    String: "String",
+    Integer: "Integer",
+    Long: "Long",
+    Decimal: "Decimal",
+    Boolean: "Boolean",
+    DateTime: "DateTime",
+    DateTimeOffset: "DateTimeOffset",
+    Json: "Json",
+};
+exports.PropertyDataType = PropertyDataType;
+const DataType = Object.assign(Object.assign({}, PropertyDataType), { Relation: "Relation" });
+class TypeInfo {
+    constructor(type_, isArray) {
+        this.name = type_;
+        this.type = type_;
+        this.isArray = !!isArray;
+    }
+}
+exports.TypeInfo = TypeInfo;
+exports.default = DataType;

package/dist/contracts/base/entity-base.d.ts

@@ -0,0 +1,65 @@
+import { MapStringTo, Nullable, NullableResultPromise } from "../../base-types";
+import { IContentHubClient } from "../../clients/content-hub-client";
+import CultureInfo from "../../culture-info";
+import { MemberLoadOption } from "../querying/member-load-option";
+import { IPropertyLoadOption } from "../querying/property-load-option";
+import { IRelationLoadOption } from "../querying/relation-load-option";
+import { PropertyDataType, PropertyValue } from "./data-type";
+import { IEntity } from "./entity";
+import { EntityConstructionArgs } from "./entity-construction-args";
+import { IEntityDefinition } from "./entity-definition";
+import { IMember } from "./member";
+import { IProperty } from "./property";
+import { PropertyManager } from "./property-manager";
+import { IRelation, RelationType } from "./relation";
+import { RelationManager } from "./relation-manager";
+import { RelationRole } from "./relation-role";
+import { IRendition } from "./rendition";
+export declare abstract class EntityBase implements IEntity {
+    protected readonly _client: IContentHubClient;
+    protected readonly _members: MapStringTo<IMember>;
+    protected readonly _propertyManager: PropertyManager;
+    protected readonly _relationManager: RelationManager;
+    id?: number;
+    identifier: Nullable<string>;
+    definitionName: string;
+    readonly lockedBy: Nullable<number>;
+    readonly lockedOn: Nullable<Date>;
+    isRootTaxonomyItem: boolean;
+    isPathRoot: boolean;
+    inheritsSecurity: boolean;
+    isSystemOwned: boolean;
+    version: number;
+    cultures: Array<CultureInfo>;
+    protected _properties: Array<IProperty>;
+    get properties(): ReadonlyArray<IProperty>;
+    protected _relations: Array<IRelation>;
+    get relations(): ReadonlyArray<IRelation>;
+    readonly createdOn?: Date;
+    readonly createdBy?: number;
+    readonly modifiedOn?: Date;
+    readonly modifiedBy?: number;
+    isTracking: boolean;
+    get canDoLazyLoading(): boolean;
+    get isDirty(): boolean;
+    get isNew(): boolean;
+    abstract get renditions(): Array<IRendition>;
+    constructor(client: IContentHubClient, args: EntityConstructionArgs);
+    private isProperty;
+    getProperty<T extends IProperty = IProperty>(name: string): Nullable<T>;
+    getPropertyAsync<T extends IProperty = IProperty>(name: string, loadOption?: MemberLoadOption): NullableResultPromise<T>;
+    getPropertyValue<T extends PropertyDataType | unknown = unknown, B extends boolean = false>(name: string, culture?: CultureInfo): PropertyValue<T, B>;
+    getPropertyValueAsync<T extends PropertyDataType | unknown = unknown, B extends boolean = false>(name: string, loadOption?: MemberLoadOption, culture?: CultureInfo): NullableResultPromise<PropertyValue<T, B>>;
+    setPropertyValue<T extends PropertyDataType, B extends boolean = false>(name: string, value: PropertyValue<T, B>, culture?: CultureInfo): void;
+    getRelation(name: string, role?: RelationRole, _returnNull?: boolean): Nullable<RelationType>;
+    getRelationAsync(name: string, role?: RelationRole | undefined, loadOption?: MemberLoadOption | undefined): NullableResultPromise<RelationType>;
+    loadPropertiesAsync(propertyLoadOption: IPropertyLoadOption): Promise<boolean>;
+    loadRelationsAsync(relationLoadOption: IRelationLoadOption): Promise<boolean>;
+    loadMembersAsync(propertyLoadOption: IPropertyLoadOption, relationLoadOption: IRelationLoadOption): Promise<boolean>;
+    getEntityDefinitionAsync(): Promise<IEntityDefinition>;
+    abstract getRendition(name: string): Nullable<IRendition>;
+    abstract getPermissionsAsync(): Promise<Array<string>>;
+    startTracking(): void;
+    markClean(): void;
+    private getDirtyTrackingMembers;
+}

package/dist/contracts/base/entity-base.js

@@ -0,0 +1,362 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBase = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const ta_json_1 = require("ta-json");
+const error_messages_1 = __importDefault(require("../../error-messages"));
+const argument_error_1 = require("../../errors/argument-error");
+const not_loaded_error_1 = require("../../errors/not-loaded-error");
+const schema_error_1 = require("../../errors/schema-error");
+const guard_1 = __importDefault(require("../../guard"));
+const culture_load_option_1 = require("../querying/culture-load-option");
+const entity_load_configuration_1 = require("../querying/entity-load-configuration");
+const member_load_option_1 = require("../querying/member-load-option");
+const entity_construction_args_1 = require("./entity-construction-args");
+const member_definition_type_1 = require("./member-definition-type");
+const property_1 = require("./property");
+const property_manager_1 = require("./property-manager");
+const relation_1 = require("./relation");
+const relation_manager_1 = require("./relation-manager");
+let EntityBase = class EntityBase {
+    constructor(client, args) {
+        this._members = {};
+        guard_1.default.notNullOrUndefined(client);
+        guard_1.default.notNullOrUndefined(args);
+        guard_1.default.arrayNoneNullOrInvariantCulture(args.cultures);
+        guard_1.default.arrayNoneNullOrUndefined(args.properties);
+        guard_1.default.arrayNoneNullOrUndefined(args.relations);
+        this._client = client;
+        this.definitionName = args.definitionName;
+        this.id = args.id || undefined;
+        this.identifier = args.identifier;
+        this.cultures = args.cultures;
+        this._propertyManager = new property_manager_1.PropertyManager(client, args.properties, this);
+        this._relationManager = new relation_manager_1.RelationManager(client, args.relations, this);
+    }
+    get properties() {
+        return this._propertyManager.getProperties();
+    }
+    get relations() {
+        return this._relationManager.getRelations();
+    }
+    get canDoLazyLoading() {
+        return !this.isNew && !!this.id;
+    }
+    get isDirty() {
+        if (!this.isTracking) {
+            return false;
+        }
+        for (const dirtyTracker of this.getDirtyTrackingMembers()) {
+            if (dirtyTracker.isDirty) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get isNew() {
+        return !this.id || this.id <= 0;
+    }
+    isProperty(member) {
+        return member && member.definitionType === member_definition_type_1.MemberDefinitionType.Property;
+    }
+    getProperty(name) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const property = this._propertyManager.getProperty(name);
+        if (property == null) {
+            const errorMessage = string_format_1.default(error_messages_1.default.Entity.PropertyNotFound, name, this.id, this.definitionName);
+            throw new not_loaded_error_1.NotLoadedError(errorMessage);
+        }
+        return property;
+    }
+    getPropertyAsync(name, loadOption = member_load_option_1.MemberLoadOption.LazyLoading) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            guard_1.default.notNullOrUndefined(loadOption);
+            let property = this._propertyManager.getProperty(name);
+            if (property == null && loadOption == member_load_option_1.MemberLoadOption.LazyLoading) {
+                property = yield this._propertyManager.loadPropertyAsync(name);
+                if (property == null) {
+                    const errorMessage = string_format_1.default(error_messages_1.default.Entity.PropertyDoesNotExist, name, this.definitionName);
+                    throw new schema_error_1.SchemaError(errorMessage);
+                }
+            }
+            if (property == null) {
+                const errorMessage = string_format_1.default(error_messages_1.default.Entity.PropertyNotFound, name, this.id, this.definitionName);
+                throw new schema_error_1.SchemaError(errorMessage);
+            }
+            return property;
+        });
+    }
+    getPropertyValue(name, culture) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const property = this.getProperty(name);
+        if (property == null) {
+            const errorMessage = string_format_1.default(error_messages_1.default.Entity.PropertyNotFound, name, this.id, this.definitionName);
+            throw new not_loaded_error_1.NotLoadedError(errorMessage);
+        }
+        else if (property.isMultiLanguage && culture == null) {
+            throw new argument_error_1.ArgumentError(error_messages_1.default.Entity.CultureRequired);
+        }
+        else if (culture != null && !property.isMultiLanguage) {
+            throw new argument_error_1.ArgumentError(error_messages_1.default.Entity.CultureNotSupported);
+        }
+        if (property.isMultiLanguage) {
+            const cultureSensitiveProp = property;
+            return cultureSensitiveProp.getValue(culture);
+        }
+        else {
+            const cultureInsensitiveProp = property;
+            return cultureInsensitiveProp.getValue();
+        }
+    }
+    getPropertyValueAsync(name, loadOption = member_load_option_1.MemberLoadOption.LazyLoading, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            guard_1.default.notNullOrUndefined(loadOption);
+            const property = yield this.getPropertyAsync(name, loadOption);
+            if (property == null) {
+                const errorMessage = string_format_1.default(error_messages_1.default.Entity.PropertyDoesNotExist, name, this.definitionName);
+                throw new schema_error_1.SchemaError(errorMessage);
+            }
+            else if (property.isMultiLanguage && culture == null) {
+                throw new argument_error_1.ArgumentError(error_messages_1.default.Entity.CultureRequired);
+            }
+            else if (culture != null && !property.isMultiLanguage) {
+                throw new argument_error_1.ArgumentError(error_messages_1.default.Entity.CultureNotSupported);
+            }
+            if (property.isMultiLanguage) {
+                const cultureSensitiveProp = property;
+                return cultureSensitiveProp.getValue(culture);
+            }
+            else {
+                const cultureInsensitiveProp = property;
+                return cultureInsensitiveProp.getValue();
+            }
+        });
+    }
+    setPropertyValue(name, value, culture) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const property = this._propertyManager.getProperty(name);
+        if (property == null) {
+            const errorMessage = string_format_1.default(error_messages_1.default.Entity.PropertyNotFound, name, this.id, this.definitionName);
+            throw new not_loaded_error_1.NotLoadedError(errorMessage);
+        }
+        else if (property.isMultiLanguage && culture == null) {
+            throw new argument_error_1.ArgumentError(error_messages_1.default.Entity.CultureRequired);
+        }
+        else if (culture != null && !property.isMultiLanguage) {
+            throw new argument_error_1.ArgumentError(error_messages_1.default.Entity.CultureRequired);
+        }
+        if (property.isMultiLanguage) {
+            property.setValue(culture, value);
+        }
+        else {
+            property.setValue(value);
+        }
+    }
+    getRelation(name, role, _returnNull = false) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const relation = this._relationManager.getRelation(name, role);
+        if (relation == null) {
+            if (_returnNull) {
+                return null;
+            }
+            const errorMessage = string_format_1.default(error_messages_1.default.Entity.RelationNotFound, name, this.id, this.definitionName);
+            throw new not_loaded_error_1.NotLoadedError(errorMessage);
+        }
+        else if (relation_1.RelationBase.isChildToManyParentsRelation(relation)) {
+            return relation;
+        }
+        else if (relation_1.RelationBase.isChildToOneParentRelation(relation)) {
+            return relation;
+        }
+        else if (relation_1.RelationBase.isParentToManyChildrenRelation(relation)) {
+            return relation;
+        }
+        else if (relation_1.RelationBase.isParentToOneChildRelation(relation)) {
+            return relation;
+        }
+        return null;
+    }
+    getRelationAsync(name, role, loadOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            const relation = this.getRelation(name, role, true);
+            if (relation == null && loadOption == member_load_option_1.MemberLoadOption.LazyLoading) {
+                {
+                    // Scoped to be able to redefine relation as type RelationType does not match IRelation. //TODO generics?
+                    const relation = yield this._relationManager.loadRelationAsync(name, role);
+                    if (relation == null) {
+                        const errorMessage = string_format_1.default(error_messages_1.default.Entity.RelationDoesNotExist, name, this.definitionName);
+                        throw new schema_error_1.SchemaError(errorMessage);
+                    }
+                    if (relation_1.RelationBase.isChildToManyParentsRelation(relation)) {
+                        return relation;
+                    }
+                    else if (relation_1.RelationBase.isChildToOneParentRelation(relation)) {
+                        return relation;
+                    }
+                    else if (relation_1.RelationBase.isParentToManyChildrenRelation(relation)) {
+                        return relation;
+                    }
+                    else if (relation_1.RelationBase.isParentToOneChildRelation(relation)) {
+                        return relation;
+                    }
+                }
+            }
+            return relation;
+        });
+    }
+    loadPropertiesAsync(propertyLoadOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.canDoLazyLoading || propertyLoadOption == null) {
+                return false;
+            }
+            return this._propertyManager.loadPropertiesAsync(propertyLoadOption);
+        });
+    }
+    loadRelationsAsync(relationLoadOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.canDoLazyLoading || relationLoadOption == null) {
+                return false;
+            }
+            return this._relationManager.loadRelationsAsync(relationLoadOption);
+        });
+    }
+    loadMembersAsync(propertyLoadOption, relationLoadOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.canDoLazyLoading) {
+                return false;
+            }
+            const hasMissingProperties = this._propertyManager.hasMissingProperties(propertyLoadOption);
+            const hasMissingRelations = this._relationManager.hasMissingRelations(relationLoadOption);
+            if (!hasMissingProperties && !hasMissingRelations) {
+                return false;
+            }
+            const cultureLoadOption = new culture_load_option_1.CultureLoadOption([...this.cultures]);
+            const loadConfiguration = new entity_load_configuration_1.EntityLoadConfiguration(cultureLoadOption, propertyLoadOption, relationLoadOption);
+            const tempEntity = yield this._client.entities.getAsync(this.id, loadConfiguration);
+            // Import missing members
+            this._propertyManager.importMissingProperties(tempEntity);
+            this._relationManager.importMissingRelations(tempEntity);
+            return true;
+        });
+    }
+    getEntityDefinitionAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._client.entityDefinitions.getCachedAsync(this.definitionName));
+        });
+    }
+    startTracking() {
+        if (this.isTracking)
+            return;
+        this.isTracking = true;
+        for (const member of this.getDirtyTrackingMembers()) {
+            member.startTracking();
+        }
+    }
+    markClean() {
+        for (const member of this.getDirtyTrackingMembers()) {
+            member.markClean();
+        }
+    }
+    getDirtyTrackingMembers() {
+        const properties = this._propertyManager.getProperties();
+        const relations = this._relationManager.getRelations();
+        const list = [...properties, ...relations];
+        return list;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("id"),
+    __metadata("design:type", Number)
+], EntityBase.prototype, "id", void 0);
+__decorate([
+    ta_json_1.JsonProperty("identifier"),
+    __metadata("design:type", Object)
+], EntityBase.prototype, "identifier", void 0);
+__decorate([
+    ta_json_1.JsonProperty("locked_by"),
+    __metadata("design:type", Object)
+], EntityBase.prototype, "lockedBy", void 0);
+__decorate([
+    ta_json_1.JsonProperty("locked_on"),
+    __metadata("design:type", Object)
+], EntityBase.prototype, "lockedOn", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_root_taxonomy_item"),
+    __metadata("design:type", Boolean)
+], EntityBase.prototype, "isRootTaxonomyItem", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_path_root"),
+    __metadata("design:type", Boolean)
+], EntityBase.prototype, "isPathRoot", void 0);
+__decorate([
+    ta_json_1.JsonProperty("inherits_security"),
+    __metadata("design:type", Boolean)
+], EntityBase.prototype, "inheritsSecurity", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_system_owned"),
+    __metadata("design:type", Boolean)
+], EntityBase.prototype, "isSystemOwned", void 0);
+__decorate([
+    ta_json_1.JsonProperty("version"),
+    __metadata("design:type", Number)
+], EntityBase.prototype, "version", void 0);
+__decorate([
+    ta_json_1.JsonProperty("cultures"),
+    ta_json_1.JsonElementType(String),
+    __metadata("design:type", Array)
+], EntityBase.prototype, "cultures", void 0);
+__decorate([
+    ta_json_1.JsonProperty("properties"),
+    ta_json_1.JsonElementType(property_1.PropertyBase),
+    __metadata("design:type", Array)
+], EntityBase.prototype, "_properties", void 0);
+__decorate([
+    ta_json_1.JsonProperty("relations"),
+    ta_json_1.JsonElementType(relation_1.RelationBase),
+    __metadata("design:type", Array)
+], EntityBase.prototype, "_relations", void 0);
+__decorate([
+    ta_json_1.JsonProperty("created_on"),
+    __metadata("design:type", Date)
+], EntityBase.prototype, "createdOn", void 0);
+__decorate([
+    ta_json_1.JsonProperty("created_by"),
+    __metadata("design:type", Number)
+], EntityBase.prototype, "createdBy", void 0);
+__decorate([
+    ta_json_1.JsonProperty("modified_on"),
+    __metadata("design:type", Date)
+], EntityBase.prototype, "modifiedOn", void 0);
+__decorate([
+    ta_json_1.JsonProperty("modified_by"),
+    __metadata("design:type", Number)
+], EntityBase.prototype, "modifiedBy", void 0);
+EntityBase = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [Object, entity_construction_args_1.EntityConstructionArgs])
+], EntityBase);
+exports.EntityBase = EntityBase;

package/dist/contracts/base/entity-construction-args.d.ts

@@ -0,0 +1,15 @@
+import { Nullable } from "../../base-types";
+import CultureInfo from "../../culture-info";
+import { IProperty } from "./property";
+import { IRelation } from "./relation";
+import { IRendition } from "./rendition";
+export declare class EntityConstructionArgs {
+    definitionName: string;
+    id?: Nullable<number>;
+    identifier: Nullable<string>;
+    properties: Array<IProperty>;
+    relations: Array<IRelation>;
+    cultures: Array<CultureInfo>;
+    renditions: Array<IRendition>;
+    constructor(definitionName: string, init?: Omit<Partial<EntityConstructionArgs>, "definitionName">);
+}

package/dist/contracts/base/entity-construction-args.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityConstructionArgs = void 0;
+class EntityConstructionArgs {
+    constructor(definitionName, init) {
+        this.id = null;
+        this.identifier = null;
+        this.properties = [];
+        this.relations = [];
+        this.cultures = [];
+        this.renditions = [];
+        this.definitionName = definitionName;
+        Object.assign(this, init);
+    }
+}
+exports.EntityConstructionArgs = EntityConstructionArgs;