import type Nymph from './Nymph.js';
import type Entity from './Entity.js';
export type ACProperties = {
    user: string | null;
    group: string | null;
    acUser: number | null;
    acGroup: number | null;
    acOther: number | null;
    acRead: (string | null)[] | null;
    acWrite: (string | null)[] | null;
    acFull: (string | null)[] | null;
};
export type EntityReference = ['nymph_entity_reference', string, string];
export type EntityData = {
    [k: string]: any;
};
export type SerializedEntityData = {
    [k: string]: string;
};
export type EntityObject = {
    guid: string | null;
    cdate: number | null;
    mdate: number | null;
    tags: string[];
    [k: string]: any;
};
export type EntityJson = {
    class: string;
    guid: string | null;
    cdate: number | null;
    mdate: number | null;
    tags: string[];
    data: EntityData;
};
export type EntityPatch = {
    class: string;
    guid: string;
    mdate: number | null;
    set: EntityData;
    unset: string[];
    addTags: string[];
    removeTags: string[];
};
/**
 * Data Object interface.
 *
 * Objects which hold data from some type of storage.
 */
export interface DataObjectInterface {
    /**
     * Search the array for this object and return the corresponding index.
     *
     * If `strict` is false, `is()` is used to compare. If `strict` is true,
     * `equals()` is used.
     *
     * @param array The array to search.
     * @param strict Whether to use stronger comparison.
     * @returns The index if the object is in the array, -1 if it isn't.
     */
    $arraySearch(array: any[], strict?: boolean): number;
    /**
     * Delete the object from storage.
     *
     * @returns True on success, false on failure.
     */
    $delete(): Promise<boolean>;
    /**
     * Perform a more strict comparison of this object to another.
     *
     * @param object The object to compare.
     * @returns True or false.
     */
    $equals(object: any): boolean;
    /**
     * Check whether this object is in an array.
     *
     * If `strict` is false, `is()` is used to compare. If `strict` is true,
     * `equals()` is used.
     *
     * @param array The array to search.
     * @param strict Whether to use stronger comparison.
     * @returns True if the object is in the array, false if it isn't.
     */
    $inArray(array: any[], strict?: boolean): boolean;
    /**
     * Perform a less strict comparison of this object to another.
     *
     * @param object The object to compare.
     * @returns True or false.
     */
    $is(object: any): boolean;
    /**
     * Refresh the object from storage. (Bypasses Nymph's cache.)
     *
     * If the object has been deleted from storage, the database cannot be
     * reached, or a database error occurs, `refresh()` will return 0.
     *
     * @returns False if the data has not been saved, 0 if it can't be refreshed, true on success.
     */
    $refresh(): Promise<boolean | 0>;
    /**
     * Save the object to storage.
     *
     * @returns True on success, false on failure.
     */
    $save(): Promise<boolean>;
    /**
     * The object's data.
     */
    [k: string]: any;
}
/**
 * Entity interface.
 */
export interface EntityInterface extends DataObjectInterface {
    /**
     * The instance of Nymph to use for queries.
     */
    $nymph: Nymph;
    /**
     * The entity's Globally Unique ID.
     *
     * This is a 12 byte number represented as a lower case HEX string (24
     * characters).
     */
    guid: string | null;
    /**
     * The creation date of the entity as a Unix timestamp in milliseconds.
     */
    cdate: number | null;
    /**
     * The modified date of the entity as a Unix timestamp in milliseconds.
     */
    mdate: number | null;
    /**
     * Array of the entity's tags.
     */
    tags: string[];
    /**
     * Get a GUID for the entity.
     *
     * If the entity has already been saved, this will just return the GUID.
     *
     * If the entity has not yet been saved, this will return a new GUID that gets
     * held by the entity. The `guid` property will remain null, but this method
     * will then always return the same GUID. When the entity is eventually saved
     * into the database, this GUID will be used.
     */
    $getGuaranteedGUID(): string;
    /**
     * Add one or more tags.
     *
     * @param tags List of tags.
     */
    $addTag(...tags: string[]): void;
    /**
     * Replace any referenced entities in the data with sleeping references.
     *
     * Calling this function ensures that the next time a referenced entity is
     * accessed, it will be retrieved from the DB (unless it is in Nymph's cache).
     */
    $clearCache(): void;
    /**
     * Get the client enabled methods.
     *
     * @returns The names of methods allowed to be called by the frontend with serverCall.
     */
    $getClientEnabledMethods(): string[];
    /**
     * Used to retrieve the data object.
     *
     * This should only be used by Nymph to save the data into storage.
     *
     * @param includeSData Whether to include the serialized data as well.
     * @param referenceOnlyExisting Whether to only turn existing entities into references.
     * @returns The entity's data object.
     */
    $getData(includeSData?: boolean, referenceOnlyExisting?: boolean): EntityData;
    /**
     * Used to retrieve the serialized data object.
     *
     * This should only be used by Nymph to save the data object into storage.
     *
     * This method is used by Nymph to avoid unserializing data that hasn't been
     * requested yet.
     *
     * It should always be called after getData().
     *
     * @returns The entity's serialized data object.
     */
    $getSData(): SerializedEntityData;
    /**
     * Get an array of strings that **must** be unique across the current etype.
     *
     * When you try to save another entity with any of the same unique strings,
     * Nymph will throw an error.
     *
     * The default implementation of this method returns an empty array, meaning
     * there are no uniqueness constraints applied to its etype.
     *
     * @returns Resolves to an array of entity's unique constraint strings.
     */
    $getUniques(): Promise<string[]>;
    /**
     * Get the original values of the AC properties.
     *
     * @returns An object of AC properties.
     */
    $getOriginalAcValues(): ACProperties;
    /**
     * Get the current values of the AC properties.
     *
     * @returns An object of AC properties.
     */
    $getCurrentAcValues(): ACProperties;
    /**
     * Get an object that holds the same data as the entity.
     *
     * This provides an object that can be validated.
     *
     * @returns A pure object representation of the entity.
     */
    $getValidatable(): Object;
    /**
     * Get the entity's tags.
     *
     * Using this instead of accessing the `tags` prop directly will wake sleeping
     * references.
     *
     * @returns The entity's tags.
     */
    $getTags(): string[];
    /**
     * Check that the entity has all of the given tags.
     *
     * @param tags List of tags.
     * @returns True or false.
     */
    $hasTag(...tags: string[]): boolean;
    /**
     * Accept JSON data from the client.
     *
     * This function uses the security protection lists:
     *
     * - $protectedTags
     * - $protectedData
     * - $allowlistTags
     * - $allowlistData
     *
     * @param input The input data. Please note, this will be modified (destroyed).
     * @param allowConflict Allow to accept data that is older than the current data.
     */
    $jsonAcceptData(input: EntityJson, allowConflict?: boolean): void;
    /**
     * Accept JSON patch from the client.
     *
     * This function uses the security protection lists:
     *
     * - $protectedTags
     * - $protectedData
     * - $allowlistTags
     * - $allowlistData
     *
     * @param patch The patch data. Please note, this will be modified (destroyed).
     * @param allowConflict Allow to accept data that is older than the current data.
     */
    $jsonAcceptPatch(patch: EntityPatch, allowConflict?: boolean): void;
    /**
     * Used to set the data.
     *
     * This should only be used by Nymph to push the data from storage or the
     * client.
     *
     * `sdata` is used by Nymph to avoid unserializing data that hasn't been
     * requested yet.
     *
     * If `source` is set to "server", the data is coming from the DB or the
     * cache. If not, assume the data is coming from the client and can't be
     * trusted.
     *
     * @param data The data object.
     * @param sdata The serialized data object.
     * @param source If this is set to "server", the data is coming from the DB.
     */
    $putData(data: EntityData, sdata?: SerializedEntityData, source?: 'server'): void;
    /**
     * Remove one or more tags.
     *
     * @param tags List of tags.
     */
    $removeTag(...tags: string[]): void;
    /**
     * Return a Nymph Entity Reference for this entity.
     *
     * If the entity hasn't been saved yet (and has no GUID), it will use the
     * guaranteed GUID from `$getGuaranteedGUID`, unless `existingOnly` is true,
     * then it will return the entity.
     *
     * @param existingOnly Whether to only turn existing entities into references.
     * @returns A Nymph Entity Reference array.
     */
    $toReference(existingOnly?: boolean): EntityReference | EntityInterface;
    /**
     * Set whether to use "skipAc" when accessing entity references.
     *
     * @param useSkipAc True or false, whether to use it.
     */
    $useSkipAc(useSkipAc: boolean): void;
}
export type EntityConstructor<D extends EntityData = EntityData, E extends Entity<D> = Entity<D>> = (new (...args: any[]) => E) & {
    [k in keyof typeof Entity]: (typeof Entity)[k];
};