import { Transaction, CollectionReference } from "@firebase/firestore-types";
import { GetAllFilters } from "./core/interfaces";
import { TypeConstructor, SchemaField, ListField, LookUpField, NumberField, SchemaFieldConstructor } from "./types/interfaces";
import { FirestoreWrapper } from "./firebase/interfaces";
export interface Record {
    id: string;
    updated_at: Date;
    created_at: Date;
    [key: string]: any;
}
export declare type QueryObject = {
    [key: string]: boolean | QueryObject;
};
export declare type SnapshotUnsubscribe = () => void;
export declare type SnapshotSubscribe<T> = (onNext?: (r: T & Record) => void, error?: (r: Error) => void, completed?: () => void) => SnapshotUnsubscribe;
export declare type CreateOptions = {
    skipValidations?: boolean;
    skipEvents?: boolean;
};
export declare type DeleteOptions = {
    skipEvents?: boolean;
};
export declare type UpdateOptions = {
    skipValidations?: boolean;
    skipEvents?: boolean;
};
export declare type CreateEvent<T> = (newRecord: T & Record, transaction?: Transaction) => void | Promise<void>;
export declare type DeleteEvent<T> = (recordId: string, transaction?: Transaction) => void | Promise<void>;
export declare type UpdateEvent<T> = (getOldRecord: () => Promise<T & Record>, fieldsUpdated: Partial<T & Record>, transaction?: Transaction) => void | Promise<void>;
interface SchemaEvents<T> {
    onCreate?: CreateEvent<T>;
    onDelete?: DeleteEvent<T>;
    onUpdate?: UpdateEvent<T>;
}
export interface SchemaEventList<T> {
    onCreate?: CreateEvent<T>[];
    onDelete?: DeleteEvent<T>[];
    onUpdate?: UpdateEvent<T>[];
}
export interface SchemaFieldsDefinition {
    [name: string]: SchemaFieldConstructor | TypeConstructor;
}
export interface SchemaFieldsMap {
    [name: string]: SchemaField;
}
interface ISchema<T = any> {
    /**
     * Name of the schema
     */
    name: string;
    /**
     * Map of constructed fields
     */
    fields: SchemaFieldsMap;
    /**
     * Firestore reference to the collection that this schema is using
     */
    collectionRef: CollectionReference;
    /**
     * Creates a new document.
     * @param record An object representing the document to be created. The object can only have the keys that you defined on the schema.
     *
     * If you want the document to have an specific ID, you can add an `id` key inside the object, otherwise, dont use the `id` key to let firestore choose the value.
     *
     * @param options An object to skip some events that occur when you call this method.
     */
    create(record: T & {
        id?: string;
    }, options?: CreateOptions): Promise<T & Record>;
    /**
     * Updates an existing document.
     * @param recordId Id of the document to be updated.
     * @param newValues An object containing partially (or all) the keys defined on the schema.
     * @param options An object to skip some events that occur when you call this method.
     */
    update(recordId: string, newValues: Partial<T>, options?: UpdateOptions): Promise<void>;
    /**
     * Deletes a document.
     * @param recordId Id of the document to be deleted.
     * @param options An object to skip some events that occur when you call this method.
     */
    delete(recordId: string, options?: DeleteOptions): Promise<void>;
    /**
     * Retrieves data from firestore using as starting node a document from this collection.
     *
     * @param id Id of a document
     * @param query Object that will explain which fields will be retrieved and resolved
     *
     * The object should only contain keys that are on the schema definition.
     * Each key can have as value `false` / `true` / `QueryObject`
     *
     * - If the key has value of `false`, it means that field wont be resolved and the raw value will be returned.
     * - If the key has value of `true`, it means that field will be resolved and the result will be returned.
     * - If the key has a `QueryObject` (**the field should be of type LookUp**), the query will be executed and the resulting object will be returned.
     *
     *  You can have as many `QueryObjects` nested as you want.
     *
     * Example:
     * ```javascript
     * UserSchema.query('SOME_DOCUMENT_ID', {
     *   name: false,
     *   comments: {
     *       post: {
     *       author: {
     *         name: false,
     *         picture: true
     *       }
     *     },
     *     content: true,
     *     created_at: true
     *   }
     * })
     * ```
     *
     * `comments` is of type List<LookUps> and `post` is of type LookUp
     */
    query<R extends Record = Record>(id: string, query?: QueryObject, transaction?: Transaction): Promise<R>;
    /**
     * Retrieves a document in the same state as it is stored on firestore.
     *
     * This means fields wont be resolved.
     *
     * *eg: LookUp fields wont be replaced by the referenced document and instead you will have the id*
     * @param id Id of a document
     */
    getRaw(id: string, transaction?: Transaction): Promise<T & Record>;
    /**
     * Retrieves a document with all its fields resolved.
     *
     * *eg: LookUp fields will be replaced by the referenced document*
     * @param id Id of a document
     * @param fields List of field names that you want to retrieve.
     *
     * If you omit this argument, all the fields of the document will be resolved and returned.
     */
    get<R extends Record = Record>(id: string, fields?: string[], transaction?: Transaction): Promise<R>;
    /**
     * Retrieves multiple documents from this collection
     * @param filters Filter object to avoid retrieving the entire collection. You should probably always use this argument.
     */
    getAll(filters?: GetAllFilters): Promise<(T & Record)[]>;
    /**
     * Subscribes to document updates.
     * @param id Id of a document
     * @param query Query to be executed on every event
     */
    onRecordChange<T extends Record = Record>(id: string, query?: QueryObject): {
        subscribe: SnapshotSubscribe<T>;
    };
}
declare type SaveSchemaInstance = <T>(schema: ISchema<T>) => void;
interface IStore {
    firebaseInstance: FirestoreWrapper;
    isDefined(name: string): boolean;
    define<T>(name: string, specs: SchemaFieldsMap, events: SchemaEvents<T>): SaveSchemaInstance;
    getSchema<T>(name: string): ISchema<T>;
    getSchemaFieldMap(schemaName: string): SchemaFieldsMap;
    getSchemaEvents<T>(schemaName: string): SchemaEventList<T>;
    setSchemaEvents<T>(schemaName: string, events: SchemaEvents<T>): void;
}
export interface CreateRelation {
    (): [SchemaFieldConstructor<ListField>, SchemaFieldConstructor<LookUpField>];
}
export interface CreateCountRelation {
    (listFieldName: string): SchemaFieldConstructor<NumberField>;
}
export interface CreateSumRelation {
    <T>(schemaName: string, parentKeyInsideSchema: keyof T, fieldNameToSumUp: keyof T): NumberField;
}
interface IDictionary<T> {
    [key: string]: T;
}
export { ISchema, SchemaEvents, IStore, IDictionary as Dictionary };