@sitecore/sc-contenthub-webclient-sdk 0.9.7

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

@@ -0,0 +1,108 @@
+import { MapCultureTo, Nullable } from "../../base-types";
+import { IMemberGroup } from "./member-group";
+import { IPropertyDefinition } from "./property-definition";
+import { IRelationDefinition } from "./relation-definition";
+import { RelationRole } from "./relation-role";
+import IResource from "./resource";
+/**
+ * Represents a data schema / domain model for an entity.
+ */
+export interface IEntityDefinition extends IResource {
+    /**
+     * Gets the id of this definition.
+     * This is an automatically assigned unique and strictly positive number identifying the entity definition.
+     * Value is 0, null or undefined when the definition has not been persisted.
+     */
+    readonly id?: number;
+    /**
+     * Gets a value indicating whether the entity definition is new.
+     */
+    readonly isNew: boolean;
+    /**
+     * Gets the unique and language agnostic name of the entity definition.
+     * It should be handled as case sensitive.
+     */
+    name: string;
+    /**
+     * Gets the language agnostic display format for entities of this definition.
+     */
+    displayTemplate: string;
+    /**
+     * Gets a value indicating whether entities of this entity definition are taxonomy items.
+     * They can then be used as a search facet.
+     */
+    isTaxonomyItemDefinition: boolean;
+    /**
+     * Gets a value indicating whether entities of this entity definition can be part of the so called paths, which are technically UI breadcrumbs.
+     * Example use cases are taxonomy entity definitions or M Project block entity definitions.
+     */
+    isPathEnabledDefinition: boolean;
+    /**
+     * Gets a value indicating whether the items of this definition can be sorted manually (UI related).
+     */
+    isManualSortingAllowed: boolean;
+    /**
+     * Gets a value indicating whether the entity definition is owned by the system and cannot be modified or deleted by the regular users.
+     */
+    isSystemOwned: boolean;
+    /**
+     * Gets the collection of {@link IMemberGroup}s.
+     */
+    memberGroups: Array<IMemberGroup>;
+    /**
+     * Gets a collection of the culture specific definition labels.
+     */
+    labels: MapCultureTo<string>;
+    /**
+     * Get the definition of the specified property.
+     * @param name - The name of the property
+     * @returns The property definition or null.
+     */
+    getPropertyDefinition(name: string): Nullable<IPropertyDefinition>;
+    /**
+     * Generic version to get the definition of the specified property.
+     * @param name - The name of the property
+     * @returns The property definition or null.
+     */
+    getPropertyDefinition<T extends IPropertyDefinition>(name: string): Nullable<T>;
+    /**
+     * Gets all property definitions.
+     * @returns A list of all property definitions.
+     */
+    getPropertyDefinitions(): Array<IPropertyDefinition>;
+    /**
+     * Get the definition of the specified relation.
+     * @param name - Name of the relation
+     * @param role - Relation role
+     * @returns The relation definition or null.
+     * @throws An {@link InvalidOperationError} when no role is given and the relation is a self-relation.
+     */
+    getRelationDefinition(name: string, role?: RelationRole): Nullable<IRelationDefinition>;
+    /**
+     * Get all relation definitions.
+     * @returns A list of all relations definitions.
+     */
+    getRelationDefinitions(): Array<IRelationDefinition>;
+}
+export declare class EntityDefinition implements IEntityDefinition {
+    readonly id?: number;
+    get isNew(): boolean;
+    name: string;
+    readonly createdBy?: number;
+    readonly createdOn?: Date;
+    readonly modifiedBy?: number;
+    readonly modifiedOn?: Date;
+    displayTemplate: string;
+    isTaxonomyItemDefinition: boolean;
+    isPathEnabledDefinition: boolean;
+    isManualSortingAllowed: boolean;
+    isSystemOwned: boolean;
+    memberGroups: Array<IMemberGroup>;
+    labels: MapCultureTo<string>;
+    constructor(init?: Partial<EntityDefinition>);
+    getPropertyDefinition<T extends IPropertyDefinition>(name: string): Nullable<T>;
+    getPropertyDefinitions(): Array<IPropertyDefinition>;
+    getRelationDefinition(name: string, role?: RelationRole): Nullable<IRelationDefinition>;
+    getRelationDefinitions(): Array<IRelationDefinition>;
+    private getMemberDefinitions;
+}

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

@@ -0,0 +1,126 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityDefinition = 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 invalid_operation_error_1 = require("../../errors/invalid-operation-error");
+const guard_1 = __importDefault(require("../../guard"));
+const member_group_1 = require("./member-group");
+const property_definition_1 = require("./property-definition");
+const relation_definition_1 = require("./relation-definition");
+let EntityDefinition = class EntityDefinition {
+    constructor(init) {
+        this.isSystemOwned = false;
+        Object.assign(this, init);
+        this.memberGroups = this.memberGroups || [];
+        this.labels = this.labels || {};
+    }
+    get isNew() {
+        return !this.id;
+    }
+    getPropertyDefinition(name) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        return (this.getPropertyDefinitions().find(propertyDefinition => {
+            return propertyDefinition.name === name;
+        }) || null);
+    }
+    getPropertyDefinitions() {
+        return this.getMemberDefinitions(property_definition_1.PropertyDefinition);
+    }
+    getRelationDefinition(name, role) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const relationDefinition = this.getRelationDefinitions().find(relationDefinition => {
+            return relationDefinition.name === name && (role == null || relationDefinition.role === role);
+        });
+        if ((relationDefinition === null || relationDefinition === void 0 ? void 0 : relationDefinition.associatedEntityDefinitionName) === this.name) {
+            const errorMessage = string_format_1.default(error_messages_1.default.NoRoleSpecifiedForSelfRelation, name);
+            throw new invalid_operation_error_1.InvalidOperationError(errorMessage);
+        }
+        return relationDefinition !== null && relationDefinition !== void 0 ? relationDefinition : null;
+    }
+    getRelationDefinitions() {
+        return this.getMemberDefinitions(relation_definition_1.RelationDefinition);
+    }
+    getMemberDefinitions(typeT) {
+        const members = [];
+        for (const group of this.memberGroups) {
+            for (const member of group.memberDefinitions) {
+                if (member instanceof typeT) {
+                    members.push(member);
+                }
+            }
+        }
+        return members;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("id"),
+    __metadata("design:type", Number)
+], EntityDefinition.prototype, "id", void 0);
+__decorate([
+    ta_json_1.JsonProperty("name"),
+    __metadata("design:type", String)
+], EntityDefinition.prototype, "name", void 0);
+__decorate([
+    ta_json_1.JsonProperty("created_by"),
+    __metadata("design:type", Number)
+], EntityDefinition.prototype, "createdBy", void 0);
+__decorate([
+    ta_json_1.JsonProperty("created_on"),
+    __metadata("design:type", Date)
+], EntityDefinition.prototype, "createdOn", void 0);
+__decorate([
+    ta_json_1.JsonProperty("modified_by"),
+    __metadata("design:type", Number)
+], EntityDefinition.prototype, "modifiedBy", void 0);
+__decorate([
+    ta_json_1.JsonProperty("modified_on"),
+    __metadata("design:type", Date)
+], EntityDefinition.prototype, "modifiedOn", void 0);
+__decorate([
+    ta_json_1.JsonProperty("display_template"),
+    __metadata("design:type", String)
+], EntityDefinition.prototype, "displayTemplate", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_taxonomy_item_definition"),
+    __metadata("design:type", Boolean)
+], EntityDefinition.prototype, "isTaxonomyItemDefinition", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_path_enabled_definition"),
+    __metadata("design:type", Boolean)
+], EntityDefinition.prototype, "isPathEnabledDefinition", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_manual_sorting_allowed"),
+    __metadata("design:type", Boolean)
+], EntityDefinition.prototype, "isManualSortingAllowed", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_system_owned"),
+    __metadata("design:type", Boolean)
+], EntityDefinition.prototype, "isSystemOwned", void 0);
+__decorate([
+    ta_json_1.JsonProperty("member_groups"),
+    ta_json_1.JsonElementType(member_group_1.MemberGroup),
+    __metadata("design:type", Array)
+], EntityDefinition.prototype, "memberGroups", void 0);
+__decorate([
+    ta_json_1.JsonProperty("labels"),
+    __metadata("design:type", Object)
+], EntityDefinition.prototype, "labels", void 0);
+EntityDefinition = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [Object])
+], EntityDefinition);
+exports.EntityDefinition = EntityDefinition;

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

@@ -0,0 +1,237 @@
+import { Nullable, NullableResultPromise } from "../../base-types";
+import { IExtendedContentHubClient } from "../../clients/extended-client";
+import { IPropertyLoadOption } from "../../contracts/querying/property-load-option";
+import CultureInfo from "../../culture-info";
+import { IDirtyTracking } from "../dirty-tracking/dirty-tracking";
+import { MemberLoadOption } from "../querying/member-load-option";
+import { IRelationLoadOption } from "../querying/relation-load-option";
+import DataType, { PropertyValue } from "./data-type";
+import { EntityBase } from "./entity-base";
+import { EntityConstructionArgs } from "./entity-construction-args";
+import { IEntityDefinition } from "./entity-definition";
+import { IProperty } from "./property";
+import { IRelation } from "./relation";
+import { RelationRole } from "./relation-role";
+import { IRendition } from "./rendition";
+import IResource from "./resource";
+/**
+ * Interface for an entity.
+ */
+export interface IEntity extends IResource, IDirtyTracking {
+    /**
+     * Gets the id of the entity.
+     * The id is an automatically assigned, read only, unique and strictly positive number identifying the entity.
+     * The id is null if the entity has not been persisted yet.
+     */
+    id?: number;
+    /**
+     * Gets the identifier of the entity.
+     * The identifier can be set on a new entities, until it is persisted. It must be unique.
+     * The identifier will be auto generated when it is null when persisting.
+     */
+    identifier: Nullable<string>;
+    /**
+     * Gets a value indicating whether the entity is new (id is null).
+     */
+    isNew: boolean;
+    /**
+     * Gets the name of the {@link IEntityDefinition} that defines this entity.
+     */
+    definitionName: string;
+    /**
+     * Gets the id of the user who locked this entity or null if it hasn't been locked.
+     */
+    lockedBy: Nullable<number>;
+    /**
+     * Gets the date on which this entity was locked or null if it hasn't been locked.
+     */
+    lockedOn: Nullable<Date>;
+    /**
+     * Gets or sets a value indicating whether this entity is a top level facet.
+     */
+    isRootTaxonomyItem: boolean;
+    /**
+     * Gets or sets a value indicating whether this entity is a top level path.
+     */
+    isPathRoot: boolean;
+    /**
+     * Gets or sets a value indicating whether the entity inherits security
+     * from its ancestors connected via relations with
+     */
+    inheritsSecurity: boolean;
+    /**
+     * Gets or sets a value indicating whether the entity is owned by the system
+     * and cannot be modified or deleted by the regular users.
+     */
+    isSystemOwned: boolean;
+    /**
+     * Gets the current version of the entity.
+     * Version is a monotonically increasing number (from 1 up).
+     * Any change(s) of the entity propagated to the persistent storage will cause this number to be incremented.
+     */
+    version: number;
+    /**
+     * Gets a list of all cultures that the entity was loaded with. Never returns null.
+     * All {@link ICultureSensitiveProperty} properties can only contains values for these cultures.
+     */
+    cultures: ReadonlyArray<CultureInfo>;
+    /**
+     * Gets a list of all properties that are currently loaded on the entity. Never returns null.
+     * New properties can still be added by lazy loading them.
+     */
+    properties: ReadonlyArray<IProperty>;
+    /**
+     * Gets a list of all relations that are currently loaded on the entity. Never returns null.
+     * New relations can still be added by lazy loading them.
+     */
+    relations: ReadonlyArray<IRelation>;
+    /**
+     * Gets a list of all renditions for this entity. Never returns null.
+     */
+    renditions: ReadonlyArray<IRendition>;
+    /**
+     * Checks if lazy loading is possible. Lazy loading is only possible on persisted entities.
+     */
+    readonly canDoLazyLoading: boolean;
+    /**
+     * Gets property by its name.
+     * @param name - The name of the property
+     * @returns The property.
+     * @throws A {@link NotLoadedError} when the property is not found.
+     */
+    getProperty(name: string): Nullable<IProperty>;
+    getProperty<T extends IProperty>(name: string): Nullable<T>;
+    /**
+     * Gets property by its name.
+     * If the property is not present, it can be lazy loaded when specifying the correct load option.
+     * @param name - The name of the property
+     * @param loadOption - The option to load the members with
+     * @returns The property.
+     * @throws A {@link SchemaError} when the property is not found.
+     */
+    getPropertyAsync(name: string, loadOption: MemberLoadOption): NullableResultPromise<IProperty>;
+    getPropertyAsync<T extends IProperty>(name: string, loadOption: MemberLoadOption): NullableResultPromise<T>;
+    /**
+     * Gets the value of the specified culture insensitive property.
+     * @param name - The name of the property
+     * @returns The property's value.
+     * @throws A {@link NotLoadedError} when the property is not found.
+     */
+    getPropertyValue(name: string): Nullable<unknown>;
+    getPropertyValue<T extends DataType, B extends boolean = false>(name: string): PropertyValue<T, B>;
+    /**
+     * Gets the value for the specified culture of the specified culture sensitive property.
+     * @param name - The name of the property
+     * @param culture - The culture for which to get the value
+     * @returns The property's value.
+     * @throws A {@link NotLoadedError} when the property is not found.
+     */
+    getPropertyValue(name: string, culture: CultureInfo): Nullable<unknown>;
+    getPropertyValue<T extends DataType, B extends boolean = false>(name: string, culture: CultureInfo): PropertyValue<T, B>;
+    /**
+     * Gets the value of the specified culture insensitive property.
+     * If the property is not present, it can be lazy loaded when specifying the correct load option.
+     * @param name - The name of the property
+     * @param loadOption - The option to load the members with
+     * @returns A promise which resolves to the property's value.
+     * @throws A {@link SchemaError} when the property is not found.
+     */
+    getPropertyValueAsync(name: string, loadOption: MemberLoadOption): Nullable<unknown>;
+    getPropertyValueAsync<T extends DataType, B extends boolean = false>(name: string, loadOption: MemberLoadOption): NullableResultPromise<PropertyValue<T, B>>;
+    /**
+     * Gets the value for the specified culture of the specified culture sensitive property.
+     * If the property is not present, it can be lazy loaded when specifying the correct load option.
+     * @param name - The name of the property
+     * @param loadOption - The option to load the members with
+     * @param culture - The culture for which to get the value
+     * @returns A promise which resolves to the property's value.
+     * @throws A {@link SchemaError} when the property is not found.
+     */
+    getPropertyValueAsync(name: string, loadOption: MemberLoadOption, culture: CultureInfo): Nullable<unknown>;
+    getPropertyValueAsync<T extends DataType, B extends boolean = false>(name: string, loadOption: MemberLoadOption, culture: CultureInfo): NullableResultPromise<PropertyValue<T, B>>;
+    /**
+     * Sets the value of specified culture insensitive property.
+     * @param name - The name of the property
+     * @param value - The value to set
+     * @throws A {@link NotLoadedError} when the property is not found.
+     */
+    setPropertyValue(name: string, value: unknown): void;
+    setPropertyValue<T extends DataType, B extends boolean = false>(name: string, value: PropertyValue<T, B>): void;
+    /**
+     * Sets the value for the specified culture and culture sensitive property.
+     * @param name - The name of the property
+     * @param value - The value to set
+     * @param culture - The culture for which to set the value
+     * @throws A {@link NotLoadedError} when the property is not found.
+     */
+    setPropertyValue(name: string, value: unknown, culture: CultureInfo): void;
+    setPropertyValue<T extends DataType, B extends boolean = false>(name: string, value: PropertyValue<T, B>, culture: CultureInfo): void;
+    /**
+     * Gets a relation by name.
+     * @param name - The name of the relation
+     * @param role - The role of the relation
+     * @returns The relation.
+     * @throws A {@link NotLoadedError} when the relation is not found.
+     */
+    getRelation(name: string, role?: RelationRole): Nullable<IRelation>;
+    /**
+     * Gets a relation by name.
+     * If the relation is not present, it can be lazy loaded when specifying the correct load option.
+     * @param name - The name of the relation
+     * @param role - The role of the relation
+     * @param loadOption - The load option, defaults to LazyLoading
+     * @returns A promise which resolves to the relation.
+     * @throws A {@link SchemaError} when the relation is not found.
+     */
+    getRelationAsync(name: string, role?: RelationRole, loadOption?: MemberLoadOption): NullableResultPromise<IRelation>;
+    /**
+     * Loads the specified properties on the current entity.
+     * It will only load if it is actually missing properties and does not overwrite existing properties.
+     * Culture sensitive properties will only be loaded in the current cultures.
+     * Lazy loading is only possible on entities that are not new.
+     * @param propertyLoadOption - The properties to load
+     * @returns Promise which resolves to true when the properties were added.
+     */
+    loadPropertiesAsync(propertyLoadOption: IPropertyLoadOption): Promise<boolean>;
+    /**
+     * Loads the specified relations on the current entity.
+     * It will only load if it is actually missing relations and does not overwrite existing relations.
+     * Lazy loading is only possible on entities that are not new.
+     * @param relationLoadOption - The relations to load
+     * @returns Promise which resolves to true when the relations were loaded.
+     */
+    loadRelationsAsync(relationLoadOption: IRelationLoadOption): Promise<boolean>;
+    /**
+     * Loads the specified members on the current entity.
+     * It will only load if it is actually missing members and does not overwrite existing members.
+     * @param propertyLoadOption - The properties to load
+     * @param relationLoadOption - The relations to load
+     * @returns Promise which resolves to true when the members were loaded.
+     */
+    loadMembersAsync(propertyLoadOption: IPropertyLoadOption, relationLoadOption: IRelationLoadOption): Promise<boolean>;
+    /**
+     * Gets an {@link IRendition} by name.
+     * @param name - The name of the rendition
+     * @returns Rendition.
+     */
+    getRendition(name: string): Nullable<IRendition>;
+    /**
+     * Gets the {@link IEntityDefinition} of the entity.
+     * @returns Promise which resolves to the entity definition.
+     */
+    getEntityDefinitionAsync(): Promise<IEntityDefinition>;
+    /**
+     * Gets the permissions the current user has on this entity.
+     * Note: Entity should be saved at least once.
+     * @returns Promise which resolves to a list of permissions.
+     */
+    getPermissionsAsync(): Promise<Array<string>>;
+}
+export declare class Entity extends EntityBase {
+    _client: IExtendedContentHubClient;
+    private readonly _renditions;
+    get renditions(): Array<IRendition>;
+    constructor(client: IExtendedContentHubClient, args: EntityConstructionArgs);
+    getRendition(name: string): Nullable<IRendition>;
+    getPermissionsAsync(): Promise<Array<string>>;
+}

package/dist/contracts/base/entity.js

@@ -0,0 +1,76 @@
+"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.Entity = void 0;
+const ta_json_1 = require("ta-json");
+const base_types_1 = require("../../base-types");
+const response_handler_1 = require("../../clients/response-handler");
+const error_messages_1 = __importDefault(require("../../error-messages"));
+const invalid_operation_error_1 = require("../../errors/invalid-operation-error");
+const guard_1 = __importDefault(require("../../guard"));
+const permissions_resource_1 = require("../../models/permissions-resource");
+const entity_base_1 = require("./entity-base");
+const entity_construction_args_1 = require("./entity-construction-args");
+let Entity = class Entity extends entity_base_1.EntityBase {
+    constructor(client, args) {
+        super(client, args);
+        this._renditions = new base_types_1.CaseInsensitiveStringMap();
+        if (args.renditions != null) {
+            for (const rendition of args.renditions) {
+                this._renditions[rendition.name] = rendition;
+            }
+        }
+    }
+    // extensionData: MapStringTo<object>;
+    get renditions() {
+        return Object.values(this._renditions);
+    }
+    getRendition(name) {
+        var _a, _b;
+        guard_1.default.stringNotNullOrEmpty(name);
+        const rendition = (_b = (_a = this._renditions) === null || _a === void 0 ? void 0 : _a[name]) !== null && _b !== void 0 ? _b : null;
+        return rendition;
+    }
+    getPermissionsAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            //TODO HashSet?
+            if (this.isNew) {
+                throw new invalid_operation_error_1.InvalidOperationError(error_messages_1.default.Entity.NoPermissionsOnNewEntity);
+            }
+            const link = yield this._client.linkHelper.permissionsForEntityToLinkAsync(this.id);
+            const response = yield this._client.raw.getAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+            const resource = ta_json_1.TaJson.deserialize(response.content, permissions_resource_1.PermissionsResource);
+            return resource.permissions || [];
+        });
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("renditions"),
+    __metadata("design:type", base_types_1.CaseInsensitiveStringMap)
+], Entity.prototype, "_renditions", void 0);
+Entity = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [Object, entity_construction_args_1.EntityConstructionArgs])
+], Entity);
+exports.Entity = Entity;

package/dist/contracts/base/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./resource";
+export * from "./data-type";
+export * from "./json-content-type";
+export * from "./string-content-type";
+export * from "./member-definition-type";
+export * from "./member-definition";
+export * from "./member-group";
+export * from "./member-condition";
+export * from "./relation-cardinality";
+export * from "./relation-role";
+export * from "./relation-definition";
+export * from "./property-definition";
+export * from "./property-definitions";
+export * from "./entity-definition";

package/dist/contracts/base/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resource"), exports);
+__exportStar(require("./data-type"), exports);
+__exportStar(require("./json-content-type"), exports);
+__exportStar(require("./string-content-type"), exports);
+__exportStar(require("./member-definition-type"), exports);
+__exportStar(require("./member-definition"), exports);
+__exportStar(require("./member-group"), exports);
+__exportStar(require("./member-condition"), exports);
+__exportStar(require("./relation-cardinality"), exports);
+__exportStar(require("./relation-role"), exports);
+__exportStar(require("./relation-definition"), exports);
+__exportStar(require("./property-definition"), exports);
+__exportStar(require("./property-definitions"), exports);
+__exportStar(require("./entity-definition"), exports);

package/dist/contracts/base/json-content-type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Types of string content.
+ */
+export declare enum JsonContentType {
+    /**
+     * Content represents renditions.
+     */
+    Renditions = 0
+}

package/dist/contracts/base/json-content-type.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonContentType = void 0;
+/**
+ * Types of string content.
+ */
+var JsonContentType;
+(function (JsonContentType) {
+    /**
+     * Content represents renditions.
+     */
+    JsonContentType[JsonContentType["Renditions"] = 0] = "Renditions";
+})(JsonContentType = exports.JsonContentType || (exports.JsonContentType = {}));

package/dist/contracts/base/lazy-loading-manager.d.ts

@@ -0,0 +1,4 @@
+import { IEntity } from "./entity";
+export declare class LazyLoadingManager {
+    static ensureLazyLoadingIsPossible(entity: IEntity): void;
+}

package/dist/contracts/base/lazy-loading-manager.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyLoadingManager = void 0;
+const error_messages_1 = __importDefault(require("../../error-messages"));
+const guard_1 = __importDefault(require("../../guard"));
+class LazyLoadingManager {
+    static ensureLazyLoadingIsPossible(entity) {
+        guard_1.default.notNullOrUndefined(entity);
+        if (!entity.canDoLazyLoading) {
+            throw error_messages_1.default.Entity.CannotLazyLoad;
+        }
+    }
+}
+exports.LazyLoadingManager = LazyLoadingManager;