@memberjunction/global 2.112.0 → 2.113.0

package/dist/generic/baseEntity.d.ts

@@ -1,691 +0,0 @@
-import { EntityFieldInfo, EntityInfo, EntityFieldTSType, EntityPermissionType, RecordChange, EntityRelationshipInfo } from './entityInfo';
-import { EntityDeleteOptions, EntitySaveOptions, IEntityDataProvider, IRunQueryProvider, IRunReportProvider, IRunViewProvider, SimpleEmbeddingResult } from './interfaces';
-import { UserInfo } from './securityInfo';
-import { TransactionGroupBase } from './transactionGroup';
-import { CompositeKey, FieldValueCollection } from './compositeKey';
-import { Subscription } from 'rxjs';
-import { z } from 'zod';
-import { ValidationResult } from '../ValidationTypes';
-/**
- * Represents a field in an instance of the BaseEntity class. This class is used to store the value of the field, dirty state, as well as other run-time information about the field. The class encapsulates the underlying field metadata and exposes some of the more commonly
- * used properties from the entity field metadata.
- */
-export declare class EntityField {
-    /**
-     * Static object containing the value ranges for various SQL number types.
-     * This is used to validate the value of the field when it is set or validated.
-     */
-    static readonly SQLTypeValueRanges: {
-        int: {
-            min: number;
-            max: number;
-        };
-        bigint: {
-            min: number;
-            max: number;
-        };
-        smallint: {
-            min: number;
-            max: number;
-        };
-        tinyint: {
-            min: number;
-            max: number;
-        };
-        decimal: {
-            min: number;
-            max: number;
-        };
-        numeric: {
-            min: number;
-            max: number;
-        };
-        float: {
-            min: number;
-            max: number;
-        };
-        real: {
-            min: number;
-            max: number;
-        };
-        money: {
-            min: number;
-            max: number;
-        };
-    };
-    /**
-     * Indicates whether the active status of the field should be asserted when accessing or setting the value.
-     * Starts off as false and turns to true after contructor is done doing all its setup work. Internally, this can be
-     * temporarily turned off to allow for legacy fields to be created without asserting the active status.
-     */
-    private _assertActiveStatusRequired;
-    private _entityFieldInfo;
-    private _OldValue;
-    private _Value;
-    private _NeverSet;
-    get Name(): string;
-    get FieldType(): EntityFieldTSType;
-    get SQLType(): string;
-    get IsPrimaryKey(): boolean;
-    get NeedsQuotes(): boolean;
-    /**
-     * Removes spaces from the field name and returns the result.
-     */
-    get CodeName(): string;
-    get IsUnique(): boolean;
-    /**
-     * Returns the current value of the field.
-     */
-    get Value(): any;
-    get ReadOnly(): boolean;
-    get EntityFieldInfo(): EntityFieldInfo;
-    /**
-     * Returns true if the field is a uniqueidentifier in the database.
-     */
-    get IsUniqueIdentifier(): boolean;
-    /**
-     * Returns true if the field has a default value set
-     */
-    get HasDefaultValue(): boolean;
-    /**
-     * Sets the value of the field. If the field is read only, nothing happens. If the field is not read only, the value is set and the internal representation of the dirty flag is flipped if the value is different from the old value.
-     */
-    set Value(value: any);
-    /**
-     * Resets the NeverSet flag - this is generally an internal method but is available when working with read only fields (mainly primary key fields) to allow them
-     * to be set/changed once after the object is created. This is useful for scenarios where you want to set a read only field
-     * after the object is created, but only once. This is typically used in the BaseEntity class when loading an entity from an array of values or the DB and reusing an existing object.
-     */
-    ResetNeverSetFlag(): void;
-    /**
-     * Returns true if the field is dirty, false otherwise. A field is considered dirty if the value is different from the old value. If the field is read only, it is never dirty.
-     */
-    get Dirty(): boolean;
-    /**
-     * Helper method to convert a value to boolean for comparison purposes.
-     * Treats truthy values as true regardless of data type.
-     */
-    private convertToBoolean;
-    /**
-     * Helper method to check if a SQL type is numeric.
-     */
-    private isNumericType;
-    /**
-     * Helper method to convert a value to number for comparison purposes.
-     */
-    private convertToNumber;
-    /**
-     * Convenience method to format the value of the field. This method calls the static method on EntityFieldInfo to do the actual formatting.
-     * @param decimals
-     * @param currency
-     * @returns
-     */
-    FormatValue(decimals?: number, currency?: string): string;
-    /**
-     * Validates the current value of the field. If the field is read only, or if the field is marked to skip validation, nothing happens.
-     * If the field is not read only, and the field is not marked to skip validation, the value is checked against the validation rules defined in the metadata for the field.
-     * @returns
-     */
-    Validate(): ValidationResult;
-    constructor(fieldInfo: EntityFieldInfo, Value?: any);
-    /**
-     * This method will set the internal Old Value which is used to track dirty state, to the current value of the field. This effectively resets the dirty state of the field to false. Use this method sparingly.
-     */
-    ResetOldValue(): void;
-    /**
-     * This property temporarily will set the active status assertions for this particular instance of EntityField.
-     * It is temporary because other behaviors in the class instance could reset this value for example calling
-     * ResetOldValue() or another caller setting this property to another value.
-     */
-    get ActiveStatusAssertions(): boolean;
-    set ActiveStatusAssertions(value: boolean);
-    /**
-     * Returns the old value of the field. This is the value that was set when the field was last loaded from the database.
-     */
-    get OldValue(): any;
-}
-export declare class DataObjectRelatedEntityParam {
-    relatedEntityName: string;
-    filter?: string;
-    maxRecords?: number;
-}
-export declare class DataObjectParams {
-    oldValues: boolean;
-    omitNullValues: boolean;
-    omitEmptyStrings: boolean;
-    excludeFields: string[];
-    includeRelatedEntityData: boolean;
-    relatedEntityList: DataObjectRelatedEntityParam[];
-    constructor(oldValues?: boolean, omitNullValues?: boolean, omitEmptyStrings?: boolean, excludeFields?: string[], includeRelatedEntityData?: boolean, relatedEntityList?: DataObjectRelatedEntityParam[]);
-}
-export declare class BaseEntityAIActionParams {
-    name: string;
-    actionId: string;
-    modelId: string;
-    systemPrompt: string;
-    userMessage: string;
-    result: any;
-}
-/**
- * Used for storing the result of a Save or Delete or other transactional operation within a BaseEntity
- */
-export declare class BaseEntityResult {
-    /**
-     * True if successful, false otherwise
-     */
-    Success: boolean;
-    /**
-     * The type of operation that was performed
-     */
-    Type: 'create' | 'update' | 'delete';
-    /**
-     * A message for an end user
-     */
-    Message: string;
-    /**
-     * Optional, a structured error object with additional information
-     */
-    Error?: any;
-    /**
-     * Optional, a list of structured error objects with additional information
-     */
-    Errors?: any[];
-    /**
-     * A copy of the values of the entity object BEFORE the operation was performed
-     */
-    OriginalValues: {
-        FieldName: string;
-        Value: any;
-    }[];
-    /**
-     * A copy of the values of the entity object AFTER the operation was performed
-     */
-    NewValues: {
-        FieldName: string;
-        Value: any;
-    }[];
-    /**
-     * Timestamp when the operation started
-     */
-    StartedAt: Date;
-    /**
-     * Timestamp when the operation ended
-     */
-    EndedAt: Date;
-    constructor(success?: boolean, message?: string, type?: 'create' | 'update' | 'delete');
-    /**
-     * Returns a complete message that includes the Message property (if present), the Error property (if present), and any Errors array items (if present).
-     */
-    get CompleteMessage(): string;
-}
-/**
- * Event type that is used to raise events and provided structured callbacks for any caller that is interested in registering for events.
- * This type is also used for whenever a BaseEntity instance raises an event with MJGlobal.
- */
-export declare class BaseEntityEvent {
-    /**
-     * The type of event that is being raised. transaction_ready is used to indicate that a transaction is ready to be submitted for execution. The TransactionGroup class uses this to know that all async preprocessing is done and it can now submit the transaction.
-     */
-    type: 'new_record' | 'save' | 'delete' | 'transaction_ready' | 'other';
-    /**
-     * If type === 'save' this property can either be 'create' or 'update' to indicate the type of save operation that was performed.
-     */
-    saveSubType?: 'create' | 'update';
-    /**
-     * Any payload that is associated with the event. This can be any type of object and is used to pass additional information about the event.
-     */
-    payload: any;
-    /**
-     * The BaseEntity object that is raising the event.
-     */
-    baseEntity: BaseEntity;
-}
-/**
- * Base class used for all entity objects. This class is abstract and is sub-classes for each particular entity using the CodeGen tool. This class provides the basic functionality for loading, saving, and validating entity objects.
- */
-export declare abstract class BaseEntity<T = unknown> {
-    private _EntityInfo;
-    private _Fields;
-    private _recordLoaded;
-    private _contextCurrentUser;
-    private _transactionGroup;
-    private _eventSubject;
-    private _resultHistory;
-    private _provider;
-    private _everSaved;
-    constructor(Entity: EntityInfo, Provider?: IEntityDataProvider | null);
-    /**
-     * Returns this provider to be used for a given instance of a BaseEntity derived subclass. If the provider is not set, the BaseEntity.Provider is returned.
-     */
-    get ProviderToUse(): IEntityDataProvider;
-    /**
-     * Returns the RunViewProvider to be used for a given instance of a BaseEntity derived subclass.
-     */
-    get RunViewProviderToUse(): IRunViewProvider;
-    /**
-     * Returns the RunQueryProvider to be used for a given instance of a BaseEntity derived subclass.
-     */
-    get RunQueryProviderToUse(): IRunQueryProvider;
-    /**
-     * Returns the RunReportProvider to be used for a given instance of a BaseEntity derived subclass.
-     */
-    get RunReportProviderToUse(): IRunReportProvider;
-    /**
-     * This method can be used to register a callback for events that will be raised by the instance of the BaseEntity object. The callback will be called with a
-     * BaseEntityEvent object that contains the type of event and any payload that is associated with the event. Subclasses of the BaseEntity can define their
-     * own event types and payloads as needed.
-     * @param callback
-     * @returns
-     */
-    RegisterEventHandler(callback: (event: BaseEntityEvent) => void): Subscription;
-    /**
-     * If the entity object has a TransactionGroup associated with it, the TransactionGroup will be notified that we are doing some transaction pre-processing so that the TransactionGroup can
-     * properly wait for those pre-processing steps to complete before submitting the transaction. This method should generally NOT be called by anyone other than a provider that is handling
-     * the tier-specific processing for the entity object.
-     */
-    RegisterTransactionPreprocessing(): void;
-    /**
-     * Raises the transaction_ready event. This is used to indicate that the entity object is ready to be submitted for transaction processing. This is used by the TransactionGroup class to know when all async preprocessing is
-     * done and it can submit the transaction. This is an internal method and shouldn't be used by sub-classes or external callers in most cases. It is primarily used by Provider classes who are handling the tier-specific processing
-     * for the entity object.
-     */
-    RaiseReadyForTransaction(): void;
-    private static _baseEventCode;
-    /**
-     * When a BaseEntity class raises an event with MJGlobal, the eventCode property is set to this value. This is used to identify events that are raised by BaseEntity objects.
-     * Any MJGlobal event that is raised by a BaseEntity class will use a BaseEntityEvent type as the args parameter
-     */
-    static get BaseEventCode(): string;
-    /**
-     * Used for raising events within the BaseEntity and can be used by sub-classes to raise events that are specific to the entity.
-     */
-    protected RaiseEvent(type: BaseEntityEvent["type"], payload: any, saveSubType?: BaseEntityEvent["saveSubType"]): void;
-    /**
-     * This method MUST be called right after the class is instantiated to provide an async/await pair for any asynchronous operations a given entity needs to do when it is first
-     * created/configured. When you call Metadata/Provider GetEntityObject() this is done automatically for you. In nearly all cases you should go through GetEntityObject() anyway
-     * and not ever directly instantiate a BaseEntity derived class.
-     */
-    Config(contextUser: UserInfo): Promise<void>;
-    /**
-     * Returns true if the record has been saved to the database, false otherwise. This is a useful property to check to determine if the record is a "New Record" or an existing one.
-     */
-    get IsSaved(): boolean;
-    /**
-     * Transaction Groups are used to group multiple transactions into a single ATOMic transaction in a database. They are also useful even in situations with ATOMicity is less important but you want
-     * to submit a group of changes to the API server in a single network call.
-     */
-    get TransactionGroup(): TransactionGroupBase;
-    set TransactionGroup(group: TransactionGroupBase);
-    /**
-     * The result history shows the history of the attempted transactions (Save and Delete) for this particular entity object. This is useful for tracking the results of operations on the entity object.
-     */
-    get ResultHistory(): BaseEntityResult[];
-    /**
-     * Returns the most recent result from the result history. If there are no results in the history, this method will return null.
-     */
-    get LatestResult(): BaseEntityResult;
-    /**
-     * Access to the underlying metadata for the entity object.
-     */
-    get EntityInfo(): EntityInfo;
-    get Fields(): EntityField[];
-    /**
-     * Convenience method to access a field by name. This method is case-insensitive and will return null if the field is not found. You can do the same thing with more fine tune controlled by accessing the Fields property directly.
-     * @param fieldName
-     * @returns
-     */
-    GetFieldByName(fieldName: string): EntityField | null;
-    /**
-     * Returns true if the object is Dirty, meaning something has changed since it was last saved to the database, and false otherwise. For new records, this will always return true.
-     */
-    get Dirty(): boolean;
-    /**
-     * Returns an array of all primary key fields for the entity. If the entity has a composite primary key, this method will return an array of all primary key fields.
-     * If the entity has a single primary key, this method will return an array with a single field in it.
-     */
-    get PrimaryKeys(): EntityField[];
-    private _compositeKey;
-    /**
-     * Returns the primary key for the record. The CompositeKey class is a multi-valued key that can have any number of key/value pairs within it. Always traverse the full
-     * set of key/value pairs to get the full primary key for the record.
-     */
-    get PrimaryKey(): CompositeKey;
-    /**
-     * Helper method to return just the first Primary Key
-     */
-    get FirstPrimaryKey(): EntityField;
-    /**
-     * Returns true if the record has been loaded from the database, false otherwise. This is useful to check to see if the record is in a "New Record" state or not.
-     */
-    get RecordLoaded(): boolean;
-    /**
-     * Sets the value of a given field. If the field doesn't exist, nothing happens.
-     * The field's type is used to convert the value to the appropriate type.
-     * @param FieldName
-     * @param Value
-     */
-    Set(FieldName: string, Value: any): void;
-    /**
-     * Returns the value of the field with the given name. If the field is a date, and the value is a string, it will be converted to a date object.
-     * @param FieldName
-     * @returns
-     */
-    Get(FieldName: string): any;
-    /**
-     * NOTE: Do not call this method directly. Use the {@link From} method instead
-     *
-     * Sets any number of values on the entity object from the object passed in. The properties of the object being passed in must either match the field name (in most cases) or the CodeName (which is only different from field name if field name has spaces in it)
-     * @param object
-     * @param ignoreNonExistentFields - if set to true, fields that don't exist on the entity object will be ignored, if false, an error will be thrown if a field doesn't exist
-     * @param replaceOldValues - if set to true, the old values of the fields will be reset to the values provided in the object parameter, if false, they will be left alone
-     * @param ignoreActiveStatusAssertions - if set to true, the active status assertions for the fields will be ignored, if false, an error will be thrown if a field is not active. Defaults to false.
-     */
-    SetMany(object: any, ignoreNonExistentFields?: boolean, replaceOldValues?: boolean, ignoreActiveStatusAssertions?: boolean): void;
-    /**
-     * NOTE: Do not call this method directly. Use the {@link To} method instead
-     *
-     * Utility method to create an object and return it with properties in the newly created and returned object for each field in the entity object. This is useful for scenarios where you need to be able to persist the data
-     * in a format to send to a network call, save to a file or database, etc. This method will return an object with properties that match the field names of the entity object.
-     * @param oldValues When set to true, the old values of the fields will be returned instead of the current values.
-     * @param onlyDirtyFields When set to true, only the fields that are dirty will be returned.
-     * @returns
-     */
-    GetAll(oldValues?: boolean, onlyDirtyFields?: boolean): any;
-    /**
-     * Returns a partial object that contains only the fields that have changed since the last time the record was saved. This is useful for scenarios where you want to send only the changes to the server or to a client.
-     * It is also helpful for quickly finding the fields that are "dirty".
-     * @returns
-     */
-    GetChangesSinceLastSave(): Partial<T>;
-    /**
-     * This utility method calls GetDataObject() internally and formats the result as a JSON string. If you want to get the data as an object instead of a string, call GetDataObject() directly.
-     * @param params
-     * @param minifyJSON
-     * @returns
-     */
-    GetDataObjectJSON(params?: DataObjectParams, minifyJSON?: boolean): Promise<string>;
-    /**
-     * This utility method generates a completely new object that has properties that map to the fields and values in the entity at the time it is called. It is a copy, NOT a link, so any changes
-     * made to the object after calling this method will NOT be reflected in the object that is returned. This is useful for things like sending data to a client, or for use in a view model.
-     * @param params
-     * @returns
-     */
-    GetDataObject(params?: DataObjectParams): Promise<any>;
-    GetRelatedEntityData(re: EntityRelationshipInfo, filter?: string, maxRecords?: number): Promise<any[]>;
-    GetRelatedEntityDataExt(re: EntityRelationshipInfo, filter?: string, maxRecords?: number): Promise<{
-        Data: any[];
-        TotalRowCount: number;
-    }>;
-    private init;
-    /**
-     * This method will copy the values from the other entity object into the current one. This is useful for things like cloning a record.
-     * This method will ONLY copy values for fields that exist in the current entity object. If the other object has fields that don't exist in the current object, they will be ignored.
-     * @param other - the other entity object to copy values from
-     * @param includePrimaryKeys - if true, the primary keys will be copied as well, if false, they will be ignored, defaults to false and generally you want to leave it that way
-     * @param replaceOldValues - if true, the old values of the fields will be reset to the values provided in the other parameter, if false, they will be left alone, defaults to false and generally you want to leave it that way
-     */
-    CopyFrom(other: BaseEntity, includePrimaryKeys?: boolean, replaceOldValues?: boolean): boolean;
-    /**
-     * The ContextCurrentUser is a property used to manually set the "current" user for scenarios, primarily on the server side, where the user changes per request. For situations where there is no global CurrentUser in the Metadata.Provider,
-     * you MUST set this property to the user you want to use for the current operation. If you used Metadata.GetEntityObject() to get the entity object, this property will be set automatically for you as that method has a parameter that can
-     * be provided for the ContextCurrentUser.
-     */
-    set ContextCurrentUser(user: UserInfo);
-    get ContextCurrentUser(): UserInfo;
-    /**
-     * This method will create a new state for the object that is equivalent to a new record including default values.
-     * @param newValues - optional parameter to set the values of the fields to something other than the default values. The expected parameter is an object that has properties that map to field names in this entity.
-     * This is the same as creating a NewRecord and then using SetMany(), but it is a convenience/helper approach.
-     * @returns
-     */
-    NewRecord(newValues?: FieldValueCollection): boolean;
-    private _pendingSave$;
-    /**
-     * Saves the current state of the object to the database. Uses the active provider to handle the actual saving of the record.
-     * If the record is new, it will be created, if it already exists, it will be updated.
-     *
-     * Debounces multiple calls so that if Save() is called again while a save is in progress,
-     * the second call will simply receive the same result as the first.
-     *
-     * @param options
-     * @returns Promise<boolean>
-     */
-    Save(options?: EntitySaveOptions): Promise<boolean>;
-    /**
-     * Private, internal method to handle saving the current state of the object to the database. This method is called by the public facing Save() method
-     * and is debounced to prevent multiple calls from being executed simultaneously.
-     * @param options
-     * @returns
-     */
-    private _InnerSave;
-    private finalizeSave;
-    /**
-     * Internal helper method for the class and sub-classes - used to easily get the Active User which is either the ContextCurrentUser, if defined, or the Metadata.Provider.CurrentUser if not.
-     */
-    protected get ActiveUser(): UserInfo;
-    /**
-     * Utility method that returns true if the given permission being checked is enabled for the current user, and false if not.
-     * @param type
-     * @param throwError
-     * @returns
-     */
-    CheckPermissions(type: EntityPermissionType, throwError: boolean): boolean;
-    protected ThrowPermissionError(u: UserInfo, type: EntityPermissionType, additionalInfoMessage: string): void;
-    /**
-     * This method will revert the internal state of the object back to what it was when it was last saved, or if never saved, from when it was intially loaded from the database. This is useful if you want to offer a user an "undo" type of feature in a UI.
-     * @returns
-     */
-    Revert(): boolean;
-    /**
-     * * This method loads a single record from the database. Make sure you first get the correct BaseEntity sub-class for your entity by calling Metadata.GetEntityObject() first. From there, you can
-     * call this method to load your records.
-     * * NOTE: You should not be calling this method directly from outside of a sub-class in most cases. You will use the auto-generated sub-classes that have overriden versions of this method that blow out the primary keys into individual parameters. This is much easier to program against.
-     * @param CompositeKey Wrapper that holds an array of objects that contain the field name and value for the primary key of the record you want to load. For example, if you have a table called "Customers" with a primary key of "ID", you would pass in an array with a single object like this: {FieldName: "ID", Value: 1234}.
-     * *If you had a composite primary key, you would pass in an array with multiple objects, one for each field in the primary key. You may ONLY pass in the primary key fields, no other fields are allowed.
-     * @param EntityRelationshipsToLoad Optional, you can specify the names of the relationships to load up. This is an expensive operation as it loads up an array of the related entity objects for the main record, so use it sparingly.
-     * @returns true if success, false otherwise
-     */
-    InnerLoad(CompositeKey: CompositeKey, EntityRelationshipsToLoad?: string[]): Promise<boolean>;
-    /**
-     * Loads entity data from a plain object, typically from database query results.
-     *
-     * This method is meant to be used only in situations where you are sure that the data you are loading
-     * is current in the database. MAKE SURE YOU ARE PASSING IN ALL FIELDS. The Dirty flags and other internal
-     * state will assume what is loading from the data parameter you pass in is equivalent to what is in the database.
-     *
-     * @remarks
-     * Generally speaking, you should use Load() instead of this method. The main use cases where this makes sense are:
-     * 1. On the server if you are pulling data you know is fresh from the result of another DB operation
-     * 2. If on any tier you run a fresh RunView result that gives you data from the database
-     * 3. When the RunView Object RunView() method is called with ResultType='entity_object'
-     *
-     * **Important for Subclasses**: As of v2.53.0, this method is now async to support subclasses that need to
-     * perform additional asynchronous loading operations (e.g., loading related data, fetching additional metadata).
-     *
-     * Subclasses that need to perform additional loading should override BOTH this method AND Load() to ensure
-     * consistent behavior regardless of how the entity is populated. This is because these two methods have
-     * different execution paths:
-     * - Load() fetches data from the network/database and then calls provider-specific loading
-     * - LoadFromData() is called when data is already available (e.g., from RunView results)
-     *
-     * @example
-     * ```typescript
-     * // Subclass implementation
-     * public override async LoadFromData(data: any, replaceOldValues: boolean = false): Promise<boolean> {
-     *     const result = await super.LoadFromData(data, replaceOldValues);
-     *     if (result) {
-     *         // Perform additional async loading here
-     *         await this.LoadRelatedData();
-     *         await this.LoadMetadata();
-     *     }
-     *     return result;
-     * }
-     *
-     * // Don't forget to also override Load() for consistency, unless you INTEND to have different behavior
-     * // for Load() vs LoadFromData()
-     * public override async Load(ID: string, EntityRelationshipsToLoad: string[] = null): Promise<boolean> {
-     *     const result = await super.Load(ID, EntityRelationshipsToLoad);
-     *     if (result) {
-     *         // Same additional loading as in LoadFromData
-     *         await this.LoadRelatedData();
-     *         await this.LoadMetadata();
-     *     }
-     *     return result;
-     * }
-     * ```
-     *
-     * @param data - A simple object that has properties that match the field names of the entity object
-     * @param replaceOldValues - If true, the old values of the fields will be set to the values provided
-     *                           in the data parameter; if false, they will be left alone
-     * @returns Promise<boolean> - Returns true if the load was successful
-     */
-    LoadFromData(data: any, _replaceOldValues?: boolean): Promise<boolean>;
-    /**
-     * This method is used automatically within Save() and is used to determine if the state of the object is valid relative to the validation rules that are defined in metadata. In addition, sub-classes can
-     * override or wrap this base class method to add other logic for validation.
-     *
-     * @returns ValidationResult The validation result
-     */
-    Validate(): ValidationResult;
-    /**
-     * Default value for whether async validation should be skipped.
-     * Subclasses can override this property to enable async validation by default.
-     * When the options object is passed to Save(), and it includes a value for the
-     * SkipAsyncValidation property, that value will take precedence over this default.
-     *
-     * @see {@link Save}
-     *
-     * @protected
-     */
-    get DefaultSkipAsyncValidation(): boolean;
-    /**
-     * Asynchronous validation method that can be overridden by subclasses to add custom async validation logic.
-     * This method is automatically called by Save() AFTER the synchronous Validate() passes.
-     *
-     * IMPORTANT:
-     * 1. This should NEVER be called INSTEAD of the synchronous Validate() method
-     * 2. This is meant to be overridden by subclasses that need to perform async validations
-     * 3. The base implementation just returns success - no actual validation is performed
-     *
-     * Subclasses should override this to add complex validations that require database queries
-     * or other async operations that cannot be performed in the synchronous Validate() method.
-     *
-     * @returns Promise<ValidationResult> A promise that resolves to the validation result
-     */
-    ValidateAsync(): Promise<ValidationResult>;
-    /**
-     * This method deletes a record from the database. You must call Load() first in order to load the context of the record you are deleting.
-     * @returns
-     */
-    Delete(options?: EntityDeleteOptions): Promise<boolean>;
-    /**
-     * Called before an Action is executed by the AI Engine
-     * This is intended to be overriden by subclass as needed, these methods called at the right time by the execution context
-     */
-    BeforeEntityAIAction(params: BaseEntityAIActionParams): Promise<boolean>;
-    /**
-     * Called after an Action is executed by the AI Engine
-     */
-    AfterEntityAIAction(params: BaseEntityAIActionParams): Promise<boolean>;
-    private static _globalProviderKey;
-    /**
-     * Static property to get/set the IEntityDataProvider that is used by all BaseEntity objects. This is a global setting that is used by all BaseEntity objects. It can be overriden for a given BaseEntity object instance by passing in a provider to the
-     * constructor of the BaseEntity object. Typically, a provider will pass itself into BaseEntity objects it creates to create a tight coupling between the provider and the BaseEntity objects it creates. This allows multiple concurrent
-     * connections to exist in the same process space without interfering with each other.
-     */
-    static get Provider(): IEntityDataProvider;
-    static set Provider(value: IEntityDataProvider);
-    /**
-     * Returns a list of changes made to this record, over time. Only works if TrackRecordChanges bit set to 1 on the entity you're working with.
-     */
-    get RecordChanges(): Promise<RecordChange[]>;
-    /**
-     * Static Utility method to get RecordChanges for a given entityName/KeyValuePair combination
-     * @param entityName
-     * @returns
-     */
-    static GetRecordChanges(entityName: string, primaryKey: CompositeKey, provider?: IEntityDataProvider | null): Promise<RecordChange[]>;
-    /**
-     * Strongly-typed wrapper for the {@link SetMany} method.
-     * @oaram data - the data to set on the entity object
-     * @param schema - the zod schema to validate the data against
-     */
-    From<K extends z.AnyZodObject>(data: unknown, schema?: z.infer<K>): boolean;
-    /**
-     * Strongly-typed wrapper for the {@link GetAll} method
-     * @param schema - the zod schema to validate the data against
-     */
-    To<K extends z.AnyZodObject>(schema?: K): z.infer<K> | null;
-    /**
-     * Generates vector embeddings for multiple text fields by their field names.
-     * Processes fields in parallel for better performance.
-     * @param fields - Array of field configurations specifying source text field, target vector field, and model ID field names
-     * @returns Promise that resolves to true if all embeddings were generated successfully, false if any failed
-     */
-    protected GenerateEmbeddingsByFieldName(fields: Array<{
-        fieldName: string;
-        vectorFieldName: string;
-        modelFieldName: string;
-    }>): Promise<boolean>;
-    /**
-     * Generates a vector embedding for a single text field identified by field name.
-     * Retrieves the field objects and delegates to GenerateEmbedding method.
-     * @param fieldName - Name of the text field to generate embedding from
-     * @param vectorFieldName - Name of the field to store the vector embedding
-     * @param modelFieldName - Name of the field to store the model ID used for embedding
-     * @returns Promise that resolves to true if embedding was generated successfully, false otherwise
-     */
-    protected GenerateEmbeddingByFieldName(fieldName: string, vectorFieldName: string, modelFieldName: string): Promise<boolean>;
-    /**
-     * Generates vector embeddings for multiple text fields using EntityField objects.
-     * Processes fields in parallel for better performance.
-     * @param fields - Array of field configurations with EntityField objects for source, vector, and model fields
-     * @returns Promise that resolves to true if all embeddings were generated successfully, false if any failed
-     */
-    protected GenerateEmbeddings(fields: Array<{
-        field: EntityField;
-        vectorField: EntityField;
-        modelField: EntityField;
-    }>): Promise<boolean>;
-    /**
-     * Generates a vector embedding for a single text field using AI engine.
-     * Only generates embeddings for new records or when the source field has changed.
-     * Stores both the vector embedding and the model ID used to generate it.
-     * @param field - The EntityField containing the text to embed
-     * @param vectorField - The EntityField to store the generated vector embedding (as JSON string)
-     * @param modelField - The EntityField to store the ID of the AI model used
-     * @returns Promise that resolves to true if embedding was generated successfully, false otherwise
-     */
-    protected GenerateEmbedding(field: EntityField, vectorField: EntityField, modelField: EntityField): Promise<boolean>;
-    /**
-     * In the BaseEntity class this method is not implemented. This method shoudl be implemented only in
-     * **server-side** sub-classes only by calling AIEngine or other methods to generate embeddings for a given
-     * piece of text provided. Subclasses that override this method to implement embedding support should also
-     * override @see SupportsEmbedTextLocal and return true
-     * @param textToEmbed
-     */
-    protected EmbedTextLocal(textToEmbed: string): Promise<SimpleEmbeddingResult>;
-    /**
-     * Specifies if the current object supports the @see EmbedTextLocal method or not - useful to know before calling it for conditional
-     * code that has fallbacks as needed. BaseEntity does not implement this method but server-side sub-classes often do, but it is not mandatory for
-     * any sub-class.
-     * @returns
-     */
-    SupportsEmbedTextLocal(): boolean;
-    /**
-     * private storage for vectors that might be used for this entity, typically in association with individual fields
-     * however it is possible for the string in the map to be any unique key relative to the object so you could have vectors
-     * that embed multiple fields if desired.
-     */
-    private _vectors;
-    /**
-     * Utility storage for vector embeddings that represent the active record. Each string in the Map can be any unique key relative to the object so you can
-     * use this to track vectors associated with
-     */
-    get Vectors(): Map<string, number[]>;
-    /**
-     * Resets the vector embeddings for this entity to an empty state.
-     */
-    ResetVectors(): void;
-}
-//# sourceMappingURL=baseEntity.d.ts.map