bruce-models 3.1.9 → 3.2.1

package/dist/types/common/color-css-defaults.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Dictionary of CSS color names and their hex values.
+ */
+export declare const COLOR_CSS_DEFAULTS: {
+    aliceblue: string;
+    antiquewhite: string;
+    aqua: string;
+    aquamarine: string;
+    azure: string;
+    beige: string;
+    bisque: string;
+    black: string;
+    blanchedalmond: string;
+    blue: string;
+    blueviolet: string;
+    brown: string;
+    burlywood: string;
+    cadetblue: string;
+    chartreuse: string;
+    chocolate: string;
+    coral: string;
+    cornflowerblue: string;
+    cornsilk: string;
+    crimson: string;
+    cyan: string;
+    darkblue: string;
+    darkcyan: string;
+    darkgoldenrod: string;
+    darkgray: string;
+    darkgreen: string;
+    darkgrey: string;
+    darkkhaki: string;
+    darkmagenta: string;
+    darkolivegreen: string;
+    darkorange: string;
+    darkorchid: string;
+    darkred: string;
+    darksalmon: string;
+    darkseagreen: string;
+    darkslateblue: string;
+    darkslategray: string;
+    darkslategrey: string;
+    darkturquoise: string;
+    darkviolet: string;
+    deeppink: string;
+    deepskyblue: string;
+    dimgray: string;
+    dimgrey: string;
+    dodgerblue: string;
+    firebrick: string;
+    floralwhite: string;
+    forestgreen: string;
+    fuchsia: string;
+    gainsboro: string;
+    ghostwhite: string;
+    gold: string;
+    goldenrod: string;
+    gray: string;
+    green: string;
+    greenyellow: string;
+    grey: string;
+    honeydew: string;
+    hotpink: string;
+    indianred: string;
+    indigo: string;
+    ivory: string;
+    khaki: string;
+    lavender: string;
+    lavenderblush: string;
+    lawngreen: string;
+    lemonchiffon: string;
+    lightblue: string;
+    lightcoral: string;
+    lightcyan: string;
+    lightgoldenrodyellow: string;
+    lightgray: string;
+    lightgreen: string;
+    lightgrey: string;
+    lightpink: string;
+    lightsalmon: string;
+    lightseagreen: string;
+    lightskyblue: string;
+    lightslategray: string;
+    lightslategrey: string;
+    lightsteelblue: string;
+    lightyellow: string;
+    lime: string;
+    limegreen: string;
+    linen: string;
+    magenta: string;
+    maroon: string;
+    mediumaquamarine: string;
+    mediumblue: string;
+    mediumorchid: string;
+    mediumpurple: string;
+    mediumseagreen: string;
+    mediumslateblue: string;
+    mediumspringgreen: string;
+    mediumturquoise: string;
+    mediumvioletred: string;
+    midnightblue: string;
+    mintcream: string;
+    mistyrose: string;
+    moccasin: string;
+    navajowhite: string;
+    navy: string;
+    oldlace: string;
+    olive: string;
+    olivedrab: string;
+    orange: string;
+    orangered: string;
+    orchid: string;
+    palegoldenrod: string;
+    palegreen: string;
+    paleturquoise: string;
+    palevioletred: string;
+    papayawhip: string;
+    peachpuff: string;
+    peru: string;
+    pink: string;
+    plum: string;
+    powderblue: string;
+    purple: string;
+    rebeccapurple: string;
+    red: string;
+    rosybrown: string;
+    royalblue: string;
+    saddlebrown: string;
+    salmon: string;
+    sandybrown: string;
+    seagreen: string;
+    seashell: string;
+    sienna: string;
+    silver: string;
+    skyblue: string;
+    slateblue: string;
+    slategray: string;
+    slategrey: string;
+    snow: string;
+    springgreen: string;
+    steelblue: string;
+    tan: string;
+    teal: string;
+    thistle: string;
+    tomato: string;
+    turquoise: string;
+    violet: string;
+    wheat: string;
+    white: string;
+    whitesmoke: string;
+    yellow: string;
+    yellowgreen: string;
+};

package/dist/types/common/color.d.ts

@@ -5,6 +5,10 @@ export declare namespace Color {
         blue: number;
         alpha: number;
     }
+    /**
+     * Setting for how a colour should be applied in certain contexts.
+     * For example should a 3D model's colour be replaced or blended with?
+     */
     enum EBlendMode {
         HIGHLIGHT = 0,
         REPLACE = 1,
@@ -16,7 +20,8 @@ export declare namespace Color {
     }
     function RandomColor(): IColor;
     /**
-     * Attempts to parse a given color string into a model.
+     * Attempts to parse a given css-color.
+     * On failure null is returned.
      * @param str
      * @returns
      */

package/dist/types/common/delay-queue.d.ts

@@ -8,7 +8,14 @@ export declare class DelayQueue {
     private lastCallTime;
     private delayTimeout;
     constructor(callback: () => void, delay?: number);
+    /**
+     * Request a call on the callback.
+     * @param force If true, the callback will be called immediately.
+     */
     Call(force?: boolean): void;
     private doCall;
+    /**
+     * Dispose of this object.
+     */
     Dispose(): void;
 }

package/dist/types/common/geometry.d.ts

@@ -33,6 +33,11 @@ export declare namespace Geometry {
      * @returns
      */
     function RemoveRepeatPoints(positions: Carto.ICarto[]): Carto.ICarto[];
+    /**
+     * Parses a string of points into an array of points.
+     * @param pointsStr
+     * @returns
+     */
     function ParsePoints(pointsStr: string): Carto.ICarto[];
     /**
      * Parses both string and object Bruce geometry.

package/dist/types/common/lru-cache.d.ts

@@ -1,7 +1,23 @@
+/**
+ * A simple LRU cache implementation.
+ * LRU cache is a cache that evicts the least recently used item when it is full.
+ */
 export declare class LRUCache<TKey, TValue> {
     private readonly capacity;
     private readonly cache;
     constructor(capacity: number);
+    /**
+     * Get a value from the cache.
+     * @param key
+     * @returns
+     */
     Get(key: TKey): TValue | undefined;
+    /**
+     * Set a value in the cache.
+     * @param key
+     * @param value
+     */
     Set(key: TKey, value: TValue): void;
+    Entries(): IterableIterator<[TKey, TValue]>;
+    Clear(): void;
 }

package/dist/types/custom-form/custom-form-content.d.ts

@@ -10,6 +10,9 @@ export declare namespace CustomFormContent {
         includeTitle?: boolean;
         includeTools?: boolean;
     }
+    /**
+     * A stack item is a single component that is displayed in the stack.
+     */
     interface IStackItem {
         component: Component;
         params: StackItemParams;

package/dist/types/custom-form/custom-form.d.ts

@@ -2,12 +2,35 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { CustomFormContent } from "./custom-form-content";
 /**
- * Describes the "Custom Form" concept within Bruce.
+ * Describes the "Custom Form" concept within Nextspace.
  * Custom forms are dynamic dialogs that get populated with Entity data.
  */
 export declare namespace CustomForm {
+    /**
+     * Returns cache identifier for a Custom Form by ID.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey(1);
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: number): string;
+    /**
+     * Returns cache identifier for a list of Custom Forms by Entity Type ID.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("123");
+     *     api.Cache.Remove(key);
+     * }
+     * @param typeId
+     * @returns
+     */
     function GetListCacheKey(typeId: string): string;
+    /**
+     * Describes a custom form record.
+     */
     interface IForm {
         ID?: number;
         "EntityType.ID"?: string;
@@ -15,11 +38,19 @@ export declare namespace CustomForm {
         Settings?: CustomFormContent.IContent | any;
         Type?: EType;
     }
+    /**
+     * Types of custom forms available.
+     */
     enum EType {
         Form = "GENERIC",
         Markup = "MARKUP",
         ComponentStack = "COMPONENT_STACK"
     }
+    /**
+     * Gets a custom form by ID.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         formId: number;
@@ -27,11 +58,20 @@ export declare namespace CustomForm {
     }): Promise<{
         form: IForm;
     }>;
+    /**
+     * Deletes a custom form by ID.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         formId: number;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Gets a list of custom forms by entity type ID.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         entityTypeId: string;
@@ -39,6 +79,11 @@ export declare namespace CustomForm {
     }): Promise<{
         forms: IForm[];
     }>;
+    /**
+     * Creates or updates a custom form record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         form: IForm;

package/dist/types/data-lab/data-lab.d.ts

@@ -1,6 +1,11 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Entity as E } from "../entity/entity";
+/**
+ * Describes the "Data Lab" concept within Nextspace.
+ * Data lab is a query tool that allows users to search for entities.
+ * Data lab queries can be saved for reuse.
+ */
 export declare namespace DataLab {
     enum EReqKey {
         Primary = "PrimarySelection",
@@ -15,6 +20,11 @@ export declare namespace DataLab {
         PrimaryEntityTypeID?: string;
         PrimaryEntityID?: string;
     }
+    /**
+     * Runs a DataLab query.
+     * @param params
+     * @returns
+     */
     function Run(params: {
         api?: BruceApi.Api;
         query: IQuery;

package/dist/types/data-source/data-source.d.ts

@@ -2,8 +2,30 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { EntityAttribute } from "../entity/entity-attribute";
 export declare namespace DataSource {
+    /**
+     * Returns cache identifier for a data source by ID.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey(1);
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: number): string;
+    /**
+     * Returns cache identifier for a list of data sources.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey();
+     *     api.Cache.Remove(key);
+     * }
+     * @returns
+     */
     function GetListCacheKey(): string;
+    /**
+     * Describes a data source record.
+     */
     interface ISource {
         ID?: number;
         Name: string;
@@ -20,6 +42,11 @@ export declare namespace DataSource {
         IDMapping = "IDMapping"
     }
     type Type = EType | string;
+    /**
+     * Creates or updates a data source.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         source: ISource;
         api?: BruceApi.Api;
@@ -27,16 +54,30 @@ export declare namespace DataSource {
     }): Promise<{
         source: any;
     }>;
+    /**
+     * Deletes a data source.
+     * @param params
+     */
     function Delete(params: {
         id: number;
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Gets a data source by ID.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         id: number;
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<any>;
+    /**
+     * Gets a list of data sources.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         req?: Api.IReqParams;

package/dist/types/entity/entity-attachment-type.d.ts

@@ -2,12 +2,35 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 type Type = EntityAttachmentType.EType | string;
 /**
- * Describes the "Entity Attachment Type" concept within Bruce.
+ * Describes the "Entity Attachment Type" concept within Nextspace.
  * It is a record that describes the purpose of an attachment.
  */
 export declare namespace EntityAttachmentType {
+    /**
+     * Returns cache identifier for an attachment type by ID.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("123");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: Type): string;
+    /**
+     * Returns cache identifier for a list of attachment types.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey();
+     *     api.Cache.Remove(key);
+     * }
+     * @param typeId
+     * @returns
+     */
     function GetListCacheKey(): string;
+    /**
+     * Describes an attachment type record.
+     */
     interface IType {
         Description: string;
         ID: string | EType;
@@ -17,11 +40,20 @@ export declare namespace EntityAttachmentType {
         Photo = "photo",
         Document = "document"
     }
+    /**
+     * Deletes an attachment type.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         attachmentTypeId: Type;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Creates or updates an attachment type.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         attachmentType: IType;
@@ -29,6 +61,11 @@ export declare namespace EntityAttachmentType {
     }): Promise<{
         attachmentType: IType;
     }>;
+    /**
+     * Gets a list of all attachment types.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         reqParams?: Api.IReqParams;

package/dist/types/entity/entity-attachment.d.ts

@@ -4,22 +4,50 @@ import { ClientFile } from "../client-file/client-file";
 import { EntityAttachmentType } from "./entity-attachment-type";
 type Type = EntityAttachmentType.EType | string;
 /**
- * Describes the "Entity Attachment" concept within Bruce.
+ * Describes the "Entity Attachment" concept within Nextspace.
  * An entity attachment is an arbitrary file record that is linked to an entity record.
  * The same file can be attached to multiple entities.
  */
 export declare namespace EntityAttachment {
+    /**
+     * Returns cache identifier for an attachment by ID.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("123");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: number): string;
+    /**
+     * Returns cache identifier for a list of attachments for an entity.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param typeId
+     * @returns
+     */
     function GetListCacheKey(entityId: string): string;
+    /**
+     * Describes an attachment record.
+     */
     interface IAttachment {
         ID: number;
         ClientFile?: ClientFile.IFile;
-        Group?: string;
         "ClientFile.ID": string;
         DisplayOrder?: number;
         "Entity.ID": string;
         "EntityAttachmentType.ID": Type;
+        Group?: string;
     }
+    /**
+     * Updates one or many attachment records.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -28,6 +56,10 @@ export declare namespace EntityAttachment {
     }): Promise<{
         attachments: IAttachment[];
     }>;
+    /**
+     * Updates the display order of attachments.
+     * @param params
+     */
     function UpdateOrder(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -35,12 +67,21 @@ export declare namespace EntityAttachment {
         attachments: IAttachment[];
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Deletes an attachment record.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         entityId: string;
         attachmentId: number;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Gets a list of attachments for an entity.
+     * @param params
+     * @returns
+     */
     function GetListByEntityId(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -48,6 +89,12 @@ export declare namespace EntityAttachment {
     }): Promise<{
         attachments: IAttachment[];
     }>;
+    /**
+     * Uploads a file as an attachment to an entity.
+     * This will create a client file record for the file.
+     * @param params
+     * @returns
+     */
     function Upload(params: {
         api?: BruceApi.Api;
         file: Blob;

package/dist/types/entity/entity-attribute.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Describes an entity type schema attribute.
+ */
 export declare namespace EntityAttribute {
     enum EType {
         String = "String",
@@ -6,34 +9,50 @@ export declare namespace EntityAttribute {
         Datetime = "Datetime",
         Structure = "Structure",
         Geometry = "Geometry",
-        Dictionary = "Dictionary",
         Boolean = "Boolean"
     }
+    /**
+     * Describes an entity attribute.
+     * This sits within an entity type schema.
+     */
     interface IAttribute {
         Key: string;
         Name?: string;
         Type?: EType;
-        Size?: number;
         IsIndexed?: boolean;
-        IsArray?: boolean;
         IsImportant?: boolean;
-        Description?: string;
-        Metadata?: IMetadata;
+        IsArray?: boolean;
         Structure?: IAttribute[];
+        Size?: number;
+        Metadata?: IMetadata;
         IsFamilyAttribute?: boolean;
         IsFamilyAttributeDefault?: boolean;
         Sources?: string[];
     }
+    /**
+     * Describes additional metadata for an attribute.
+     */
     interface IMetadata {
-        Description?: string;
-        Mandatory?: boolean;
-        Dictionary?: IDictionary;
+        dictionary?: IDictionary;
+        maxLength?: number;
+        min?: number;
+        max?: number;
+        unit?: string;
     }
+    /**
+     * Describes a dictionary of values for an attribute.
+     */
     interface IDictionary {
-        UseAttribute?: boolean;
-        EntityTypeID?: string;
-        SourceAttributePath?: string;
-        SourceAttribute?: IAttribute;
+        enabled?: boolean;
+        entityTypeId?: string;
+        attrPath?: string;
     }
+    /**
+     * Returns an attribute from a provided hierarchy of attributes.
+     * Eg: Use the path: ["Bruce", "ID"] to find the "ID" attribute.
+     * @param items
+     * @param path
+     * @returns
+     */
     function GetAttribute(items: IAttribute[], path: string[]): IAttribute;
 }