@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/contracts/base/property-definitions/long-property-definition.js

@@ -0,0 +1,33 @@
+"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.LongPropertyDefinition = void 0;
+const ta_json_1 = require("ta-json");
+const data_type_1 = __importDefault(require("../data-type"));
+const property_definition_1 = require("../property-definition");
+/**
+ * Long property definition.
+ */
+let LongPropertyDefinition = class LongPropertyDefinition extends property_definition_1.PropertyDefinition {
+    constructor(name, init) {
+        super(name, data_type_1.default.Long);
+        Object.assign(this, init);
+    }
+};
+LongPropertyDefinition = __decorate([
+    ta_json_1.JsonObject(),
+    ta_json_1.JsonDiscriminatorValue(data_type_1.default.Long),
+    __metadata("design:paramtypes", [String, Object])
+], LongPropertyDefinition);
+exports.LongPropertyDefinition = LongPropertyDefinition;

package/dist/contracts/base/property-definitions/string-property-definition.d.ts

@@ -0,0 +1,33 @@
+import { Nullable } from "../../../base-types";
+import { PropertyDefinition } from "../property-definition";
+import { StringContentType } from "../string-content-type";
+/**
+ *
+ * String property definition.
+ */
+export declare class StringPropertyDefinition extends PropertyDefinition {
+    /**
+     * Describes how the content should be displayed.
+     */
+    contentType: StringContentType;
+    /**
+     * A regular expression that must match the value of the property. If set to null the value is not checked.
+     */
+    validationExpression: Nullable<string>;
+    /**
+     * The name of the {@link IDataSource} to get possible values from.
+     *
+     * @remarks
+     * Is null when there is no attached datasource.
+     */
+    dataSourceName: Nullable<string>;
+    /**
+     * The name of the {@link IOptionList} to get possible values from.
+     *
+     * @remarks
+     * Is null when there is no attached option list.
+     */
+    get optionListName(): Nullable<string>;
+    set optionListName(value: Nullable<string>);
+    constructor(name: string, init?: Omit<Partial<StringPropertyDefinition>, "name">);
+}

package/dist/contracts/base/property-definitions/string-property-definition.js

@@ -0,0 +1,55 @@
+"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.StringPropertyDefinition = void 0;
+const ta_json_1 = require("ta-json");
+const data_type_1 = __importDefault(require("../data-type"));
+const property_definition_1 = require("../property-definition");
+const string_content_type_1 = require("../string-content-type");
+/**
+ *
+ * String property definition.
+ */
+let StringPropertyDefinition = class StringPropertyDefinition extends property_definition_1.PropertyDefinition {
+    constructor(name, init) {
+        super(name, data_type_1.default.String);
+        Object.assign(this, init);
+    }
+    /**
+     * The name of the {@link IOptionList} to get possible values from.
+     *
+     * @remarks
+     * Is null when there is no attached option list.
+     */
+    get optionListName() {
+        return this.dataSourceName;
+    }
+    set optionListName(value) {
+        this.dataSourceName = value;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("content_type"),
+    __metadata("design:type", Number)
+], StringPropertyDefinition.prototype, "contentType", void 0);
+__decorate([
+    ta_json_1.JsonProperty("validation_expression"),
+    __metadata("design:type", Object)
+], StringPropertyDefinition.prototype, "validationExpression", void 0);
+StringPropertyDefinition = __decorate([
+    ta_json_1.JsonObject(),
+    ta_json_1.JsonDiscriminatorValue(data_type_1.default.String),
+    __metadata("design:paramtypes", [String, Object])
+], StringPropertyDefinition);
+exports.StringPropertyDefinition = StringPropertyDefinition;

package/dist/contracts/base/property-manager.d.ts

@@ -0,0 +1,19 @@
+import { Nullable, NullableResultPromise } from "../../base-types";
+import { IContentHubClient } from "../../clients/content-hub-client";
+import { IPropertyLoadOption } from "../querying/property-load-option";
+import { IEntity } from "./entity";
+import { IProperty } from "./property";
+export declare class PropertyManager {
+    private readonly _client;
+    private readonly _entity;
+    private readonly _properties;
+    get count(): number;
+    constructor(client: IContentHubClient, properties: Array<IProperty>, entity: IEntity);
+    getProperty<T extends IProperty = IProperty>(name: string): Nullable<T>;
+    getProperties(): Array<IProperty>;
+    loadPropertyAsync<T extends IProperty = IProperty>(propertyName: string): NullableResultPromise<T>;
+    loadPropertiesAsync(propertyLoadOption: IPropertyLoadOption): Promise<boolean>;
+    hasMissingProperties(propertyLoadOption: IPropertyLoadOption): boolean;
+    importMissingProperties(entity: Nullable<IEntity>): void;
+    private fetchPropertyAsync;
+}

package/dist/contracts/base/property-manager.js

@@ -0,0 +1,114 @@
+"use strict";
+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.PropertyManager = void 0;
+const base_types_1 = require("../../base-types");
+const guard_1 = __importDefault(require("../../guard"));
+const mapping_utilities_1 = require("../../mappers/mapping-utilities");
+const entity_load_configuration_1 = require("../querying/entity-load-configuration");
+const load_options_1 = require("../querying/load-options");
+const property_load_option_1 = require("../querying/property-load-option");
+const relation_load_option_1 = require("../querying/relation-load-option");
+const lazy_loading_manager_1 = require("./lazy-loading-manager");
+class PropertyManager {
+    constructor(client, properties, entity) {
+        guard_1.default.notNullOrUndefined(entity);
+        guard_1.default.notNullOrUndefined(client);
+        guard_1.default.notNullOrUndefined(properties);
+        this._client = client;
+        this._entity = entity;
+        this._properties = new base_types_1.CaseInsensitiveStringMap();
+        for (const property of properties) {
+            this._properties[property.name] = property;
+        }
+    }
+    get count() {
+        return Object.keys(this._properties).length;
+    }
+    getProperty(name) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        return this._properties[name] || null;
+    }
+    getProperties() {
+        return [...Object.values(this._properties)];
+    }
+    loadPropertyAsync(propertyName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(propertyName);
+            lazy_loading_manager_1.LazyLoadingManager.ensureLazyLoadingIsPossible(this._entity);
+            // Check if it is already loaded
+            let property = this._properties[propertyName];
+            if (property) {
+                return property;
+            }
+            // Load the property
+            property = yield this.fetchPropertyAsync(propertyName);
+            // Add the property
+            if (property != null) {
+                this._properties[property.name] = property;
+            }
+            return property;
+        });
+    }
+    loadPropertiesAsync(propertyLoadOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(propertyLoadOption);
+            lazy_loading_manager_1.LazyLoadingManager.ensureLazyLoadingIsPossible(this._entity);
+            if (!this.hasMissingProperties(propertyLoadOption)) {
+                return false;
+            }
+            const cultureLoadOption = mapping_utilities_1.MappingUtilities.culturesToLoadOption([...this._entity.cultures]);
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(cultureLoadOption, propertyLoadOption, relation_load_option_1.RelationLoadOption.None);
+            const tempEntity = yield this._client.entities.getAsync(this._entity.id, loadConfig);
+            this.importMissingProperties(tempEntity);
+            return true;
+        });
+    }
+    hasMissingProperties(propertyLoadOption) {
+        if (propertyLoadOption == null ||
+            propertyLoadOption.loadOption === load_options_1.LoadOption.None ||
+            propertyLoadOption.properties == null ||
+            propertyLoadOption.properties.length === 0) {
+            return false;
+        }
+        if (propertyLoadOption.loadOption === load_options_1.LoadOption.All) {
+            // We don't have any info about the definition here. (Same logic as in the C# SDK)
+            return true;
+        }
+        return propertyLoadOption.properties.some(requestedPropertyName => !this._properties[requestedPropertyName]);
+    }
+    importMissingProperties(entity) {
+        guard_1.default.notNullOrUndefined(entity);
+        for (const property of entity.properties) {
+            this._properties[property.name] = property;
+        }
+    }
+    fetchPropertyAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Setup load configuration
+            const cultureLoadOption = mapping_utilities_1.MappingUtilities.culturesToLoadOption([...this._entity.cultures]);
+            const propertyLoadOption = new property_load_option_1.PropertyLoadOption(name);
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(cultureLoadOption, propertyLoadOption, relation_load_option_1.RelationLoadOption.None);
+            // Load entity
+            const entity = yield this._client.entities.getAsync(this._entity.id, loadConfig);
+            if (entity == null) {
+                return null;
+            }
+            // We only loaded this specific property, so we can just take the first one.
+            const property = entity.properties[0] || null;
+            return property;
+        });
+    }
+}
+exports.PropertyManager = PropertyManager;

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

@@ -0,0 +1,21 @@
+import { PropertyDataType, TypeInfo } from "./data-type";
+import { IMember, MemberBase } from "./member";
+export interface IProperty extends IMember {
+    readonly dataType: PropertyDataType | unknown;
+    readonly isMultiLanguage: boolean;
+}
+export declare abstract class PropertyBase<T extends PropertyDataType | unknown, B extends boolean> extends MemberBase implements IProperty {
+    readonly dataType: T | unknown;
+    readonly isMultiValue: B;
+    readonly isMultiLanguage: boolean;
+    protected constructor(name: string, typeInfo: TypeInfo<T, B>);
+    protected abstract getTypeName(): string;
+    /**
+     * Returns a string representation of the current property instance.
+     *
+     * @remarks
+     * Can not be used for serialization. Only useful during debugging or testing.
+     * Returned format: \<member format ({@link MemberBase.toString})\> ({@link PropertyDataType})
+     */
+    toString(): string;
+}

package/dist/contracts/base/property.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyBase = void 0;
+const guard_1 = __importDefault(require("../../guard"));
+const data_type_1 = require("./data-type");
+const member_1 = require("./member");
+const member_definition_type_1 = require("./member-definition-type");
+class PropertyBase extends member_1.MemberBase {
+    constructor(name, typeInfo) {
+        super(name, member_definition_type_1.MemberDefinitionType.Property);
+        this.isMultiLanguage = false;
+        guard_1.default.notNullOrUndefined(typeInfo);
+        this.dataType = typeInfo.type;
+        this.isMultiValue = typeInfo.isArray;
+    }
+    /**
+     * Returns a string representation of the current property instance.
+     *
+     * @remarks
+     * Can not be used for serialization. Only useful during debugging or testing.
+     * Returned format: \<member format ({@link MemberBase.toString})\> ({@link PropertyDataType})
+     */
+    toString() {
+        return `${super.toString()} (${data_type_1.PropertyDataType[this.dataType]})`;
+    }
+}
+exports.PropertyBase = PropertyBase;

package/dist/contracts/base/relation-cardinality.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Describes the cardinality of a relation.
+ * All values are from Parent =\> Child.
+ */
+export declare enum RelationCardinality {
+    /**
+     * One parent to many children.
+     */
+    OneToMany = 0,
+    /**
+     * Many parents to many children.
+     */
+    ManyToMany = 1,
+    /**
+     * One parent to one child.
+     */
+    OneToOne = 2
+}
+export declare type RelationCardinalityType = "OneToMany" | "ManyToMany" | "OneToOne";

package/dist/contracts/base/relation-cardinality.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationCardinality = void 0;
+/**
+ * Describes the cardinality of a relation.
+ * All values are from Parent =\> Child.
+ */
+var RelationCardinality;
+(function (RelationCardinality) {
+    /**
+     * One parent to many children.
+     */
+    RelationCardinality[RelationCardinality["OneToMany"] = 0] = "OneToMany";
+    /**
+     * Many parents to many children.
+     */
+    RelationCardinality[RelationCardinality["ManyToMany"] = 1] = "ManyToMany";
+    /**
+     * One parent to one child.
+     */
+    RelationCardinality[RelationCardinality["OneToOne"] = 2] = "OneToOne";
+})(RelationCardinality = exports.RelationCardinality || (exports.RelationCardinality = {}));

package/dist/contracts/base/relation-container.d.ts

@@ -0,0 +1,40 @@
+import { IChildRelation, IParentRelation, IRelation } from "./relation";
+import { RelationRole } from "./relation-role";
+export declare class RelationContainer {
+    relationName: string;
+    private _parentRelation;
+    get parentRelation(): IParentRelation;
+    private _childRelation;
+    get childRelation(): IChildRelation;
+    /**
+     * Checks if the relation is self-referencing.
+     */
+    get isSelfRelation(): boolean;
+    /**
+     * Checks if this contains any relation.
+     */
+    get isEmpty(): boolean;
+    constructor(relationName: string);
+    /**
+     * Checks if this contains any relation.
+     */
+    any(): boolean;
+    /**
+     * Gets the relation. If role is null and the relation is self-referencing, it will throw.
+     * Returns null if there are no loaded relations.
+     * @param role - Relation role
+     */
+    getRelation(role?: RelationRole): IRelation;
+    /**
+     * Gets an array of all loaded relations.
+     */
+    getRelations(): Array<IRelation>;
+    /**
+     * Checks if the relation with specified role is loaded.
+     */
+    relationExists(role: RelationRole): boolean;
+    /**
+     * Sets the relation on this container.
+     */
+    setRelation(relation: IRelation): void;
+}

package/dist/contracts/base/relation-container.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationContainer = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const error_messages_1 = __importDefault(require("../../error-messages"));
+const guard_1 = __importDefault(require("../../guard"));
+const relation_1 = require("./relation");
+const relation_role_1 = require("./relation-role");
+class RelationContainer {
+    constructor(relationName) {
+        guard_1.default.stringNotNullOrEmpty(relationName);
+        this.relationName = relationName;
+    }
+    get parentRelation() {
+        return this._parentRelation;
+    }
+    get childRelation() {
+        return this._childRelation;
+    }
+    /**
+     * Checks if the relation is self-referencing.
+     */
+    get isSelfRelation() {
+        return this.parentRelation != null && this.childRelation != null;
+    }
+    /**
+     * Checks if this contains any relation.
+     */
+    get isEmpty() {
+        return this.parentRelation == null && this.childRelation == null;
+    }
+    /**
+     * Checks if this contains any relation.
+     */
+    any() {
+        return this.parentRelation != null || this.childRelation != null;
+    }
+    /**
+     * Gets the relation. If role is null and the relation is self-referencing, it will throw.
+     * Returns null if there are no loaded relations.
+     * @param role - Relation role
+     */
+    getRelation(role) {
+        if (role == null) {
+            if (this.isSelfRelation) {
+                throw new Error(string_format_1.default(error_messages_1.default.Entity.SelfReferencingRelation, this.relationName));
+            }
+            if (this.parentRelation != null) {
+                return this.parentRelation;
+            }
+            else {
+                return this.childRelation;
+            }
+        }
+        else if (role === relation_role_1.RelationRole.Parent) {
+            return this.parentRelation;
+        }
+        else if (role === relation_role_1.RelationRole.Child) {
+            return this.childRelation;
+        }
+        else {
+            throw new Error(string_format_1.default(error_messages_1.default.RelationRoleMapper.UnknownRole, role));
+        }
+    }
+    /**
+     * Gets an array of all loaded relations.
+     */
+    getRelations() {
+        if (this.isSelfRelation) {
+            return [this.parentRelation, this.childRelation];
+        }
+        else if (this.parentRelation != null) {
+            return [this.parentRelation];
+        }
+        else if (this.childRelation != null) {
+            return [this.childRelation];
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * Checks if the relation with specified role is loaded.
+     */
+    relationExists(role) {
+        if (role === relation_role_1.RelationRole.Parent) {
+            return this.parentRelation != null;
+        }
+        else if (role === relation_role_1.RelationRole.Child) {
+            return this.childRelation != null;
+        }
+        else {
+            throw new Error(string_format_1.default(error_messages_1.default.RelationRoleMapper.UnknownRole, role));
+        }
+    }
+    /**
+     * Sets the relation on this container.
+     */
+    setRelation(relation) {
+        guard_1.default.notNullOrUndefined(relation);
+        if (this.relationName != relation.name) {
+            throw new Error(error_messages_1.default.Entity.RelationNameMustMatch);
+        }
+        if (relation_1.RelationBase.isParentRelation(relation)) {
+            this._parentRelation = relation;
+        }
+        else if (relation_1.RelationBase.isChildRelation(relation)) {
+            this._childRelation = relation;
+        }
+        else {
+            throw new Error(string_format_1.default(error_messages_1.default.RelationRoleMapper.UnknownRole, relation.role));
+        }
+    }
+}
+exports.RelationContainer = RelationContainer;

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

@@ -0,0 +1,123 @@
+import { MapCultureTo } from "../../base-types";
+import { IMemberDefinition, MemberDefinition } from "./member-definition";
+import { MemberDefinitionType } from "./member-definition-type";
+import { RelationCardinality } from "./relation-cardinality";
+import { RelationRole } from "./relation-role";
+/**
+ * Represents a data schema / domain model for relations on an {@link IEntityDefinition}.
+ */
+export interface IRelationDefinition extends IMemberDefinition {
+    /**
+     * Role of the relation on the {@link IEntityDefinition}.
+     * Parent and child entity definitions share the same conceptual relation definition.
+     */
+    role: RelationRole;
+    /**
+     * Cardinality of the relation from the parent's point of view.
+     */
+    cardinality: RelationCardinality;
+    /**
+     * Name of the {@link IEntityDefinition} that is linked to the other end ({@link RelationRole}) of this
+     * relation definition.
+     */
+    associatedEntityDefinitionName: string;
+    /**
+     * Indicates whether relations of this definition must have at least one child.
+     */
+    childIsMandatory: boolean;
+    /**
+     * Indicates whether relations of this definition must have at least one parent.
+     */
+    parentIsMandatory: boolean;
+    /**
+     * Indicates if this relation is used to inherit any security related meta data (parents -\> children).
+     */
+    inheritsSecurity: boolean;
+    /**
+     * Indicates whether this relation can be used for navigation to parents or children in the external services
+     * (e.g. REST API). This can prevent potentially serious memory intensive operations.
+     */
+    allowNavigation: boolean;
+    /**
+     * Indicates whether the relation allows nesting of properties on the associated entity when accessed via the
+     * external services (e.g. REST API).
+     */
+    isNested: boolean;
+    /**
+     * Collection of the property names of the associated entity to be used for nesting.
+     */
+    nestedProperties: Array<string>;
+    /**
+     * Indicates whether permissions are included when nesting this relation in an external service, in similar fashion
+     * as with property nesting.
+     */
+    nestedPermissions: boolean;
+    /**
+     * Indicates whether the relation establishes a taxonomy.
+     */
+    isTaxonomyRelation: boolean;
+    /**
+     * Indicates if the relation provides a link between parent and child taxonomy entities of the same entity
+     * definition, thus creating a taxonomy hierarchy.
+     */
+    isTaxonomyHierarchyRelation: boolean;
+    /**
+     * Indicates if the child of the relation copies full text search content of the ancestors connected via such marked
+     * relations into its full text search
+     * content.
+     */
+    contentIsCopied: boolean;
+    /**
+     * Indicates whether the child of the relation copies words collection, used for the auto–complete, of the ancestors
+     * connected via such marked relations into its collection of words used for the auto-complete functionality.
+     */
+    completionIsCopied: boolean;
+    /**
+     * Indicates whether this relation provides a link between a parent entity with
+     * {@link IEntityDefinition.isPathEnabledDefinition} or an entity with such an ancestor.
+     */
+    isPathRelation: boolean;
+    /**
+     * Indicates whether this relation provides a link between {@link IEntityDefinition.isPathEnabledDefinition}
+     * thus creating a path hierarchy.
+     */
+    isPathHierarchyRelation: boolean;
+    /**
+     * Score given to the relation which is marked as {@link IsPathHierarchyRelation}.
+     * If entity has multiple parent hierarchy relations, the paths of entity will be sorted according to this score in
+     * ascending way. The first path, if not marked otherwise, will be used as a sole entity path when only one path is
+     * required.
+     */
+    pathHierarchyScore: string;
+    /**
+     * Indicates whether this relation can be used to retrieve renditions.
+     */
+    isRenditionRelation: boolean;
+    /**
+     * Collection of the culture specific member labels of the associated relation definition.
+     */
+    associatedLabels: MapCultureTo<string>;
+}
+export declare class RelationDefinition extends MemberDefinition implements IRelationDefinition {
+    role: RelationRole;
+    cardinality: RelationCardinality;
+    associatedEntityDefinitionName: string;
+    childIsMandatory: boolean;
+    parentIsMandatory: boolean;
+    inheritsSecurity: boolean;
+    allowNavigation: boolean;
+    isNested: boolean;
+    nestedProperties: Array<string>;
+    nestedPermissions: boolean;
+    isTaxonomyRelation: boolean;
+    isTaxonomyHierarchyRelation: boolean;
+    contentIsCopied: boolean;
+    completionIsCopied: boolean;
+    isPathRelation: boolean;
+    isPathHierarchyRelation: boolean;
+    pathHierarchyScore: string;
+    isRenditionRelation: boolean;
+    associatedLabels: MapCultureTo<string>;
+    get definitionType(): MemberDefinitionType;
+    constructor(name: string, init?: Omit<Partial<RelationDefinition>, "name">);
+}