import { Query } from "queric";
import { IfOption, InfoOption, PotentialInsertOption, PotentialUpdateOption, TimestampOption } from './dbDefinitions';
import { ComplexTypesOption } from 'ziron-worker';
import { IsStrictlyAny, ObjectValues, OptionalObjectKeys, RequiredValue } from '../utils/typeUtils';
import Databox from '../../api/databox/Databox';
import StaticDatabox from '../../api/databox/StaticDatabox';
interface FilterFunctions<K, V, R> {
    /**
     * @description
     * Function to filter the items by value with a queric query.
     */
    filterByValue(query: Query<V>): R;
    /**
     * @description
     * Function to filter the items by key with a queric query.
     * @param query
     */
    filterByKey(query: Query<K>): R;
    /**
     * @description
     * Function to filter the items by pair with queric queries.
     * @param keyQuery
     * @param valueQuery
     */
    filterByPair(keyQuery: Query<K>, valueQuery: Query<V>): R;
    /**
     * @description
     * Function to select all items.
     */
    all(): R;
}
interface DeleteFunction<R> {
    /**
     * @description
     * Deletes the selected value/s.
     * Don't forget to update your database before updating the databox.
     * If you want to do multiple operations in one transaction, you should look at the bundle option.
     * Notice that in every case, the delete only happens when the key
     * on the client does exist.
     * Otherwise, the client will ignore it.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * KeyArray -> Deletes the specific value.
     * Object -> Deletes the specific value.
     * Array -> Deletes the value at the specified numeric
     * index or the last item in the array with the key "$lastIndex".
     * To delete the last item, you can use the $lastIndex string as a key.
     * @param options
     */
    delete(options?: IfOption & InfoOption & TimestampOption): R;
}
interface UpdateFunction<V, R> {
    /**
     * @description
     * Updates the selected value/s.
     * Don't forget to update your database before updating the databox.
     * If you want to do multiple operations in one transaction, you should look at the bundle option.
     * Update behaviour:
     * Notice that in every case, the update only happens when the key
     * on the client does exist.
     * Otherwise, the client will ignore or convert it to an
     * insert when potentiallyInsert is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * @param value
     * @param options
     */
    update(value: V, options?: IfOption & PotentialInsertOption & InfoOption & TimestampOption & ComplexTypesOption): R;
}
interface ArrInsertFunction<V, R> {
    /**
     * Inserts a new value in the selected array or keyArray.
     * Don't forget to update your database before updating the databox.
     * If you want to do multiple operations in one transaction, you should look at the bundle option.
     * Notice that in every case, the insert only happens when the key
     * does not exist on the client.
     * Otherwise, the client will ignore or convert it to an
     * update when potentiallyUpdate is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * KeyArray -> Inserts the value at the end with the key.
     * But if you are using a compare function, it will insert the value in the correct position.
     * Array -> Key will be parsed to int if it is a number, then it will be inserted at the index.
     * Otherwise, it is possible to insert at the end with the key "$nextIndex".
     * @param key
     * @param value
     * @param options
     */
    insert(key: string | number | '$nextIndex', value: V, options?: IfOption & PotentialUpdateOption & InfoOption & TimestampOption & ComplexTypesOption): R;
}
interface ObjInsertFunction<O extends object, R> {
    /**
     * Inserts a new value in the object.
     * Don't forget to update your database before updating the databox.
     * If you want to do multiple operations in one transaction, you should look at the bundle option.
     * Notice that in every case, the insert only happens when the key
     * does not exist on the client.
     * Otherwise, the client will ignore or convert it to an
     * update when potentiallyUpdate is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * @param property
     * @param value
     * @param options
     */
    insert<K extends OptionalObjectKeys<O>>(property: K, value: O[K], options?: IfOption & PotentialUpdateOption & InfoOption & TimestampOption & ComplexTypesOption): R;
}
interface BundleDeleteFunction<R> {
    /**
     * @description
     * Deletes the selected value/s.
     * Don't forget to update your database before updating the databox.
     * Notice that in every case, the delete only happens when the key
     * on the client does exist.
     * Otherwise, the client will ignore it.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * KeyArray -> Deletes the specific value.
     * Object -> Deletes the specific value.
     * Array -> Deletes the value at the specified numeric
     * index or the last item in the array with the key "$lastIndex".
     * To delete the last item, you can use the $lastIndex string as a key.
     * @param options
     */
    delete(options?: IfOption): R;
}
interface BundleUpdateFunction<V, R> {
    /**
     * @description
     * Updates the selected value/s.
     * Don't forget to update your database before updating the databox.
     * Update behaviour:
     * Notice that in every case, the update only happens when the key
     * on the client does exist.
     * Otherwise, the client will ignore or convert it to an
     * insert when potentiallyInsert is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * @param value
     * @param options
     */
    update(value: V, options?: IfOption & PotentialInsertOption): R;
}
interface BundleObjPartialUpdateFunction<V extends object, R> {
    /**
     * @description
     * Updates all given properties of the object.
     * Notice that internally multiple updates for each given property are built.
     * That's why this method is only available when constructing a bundle.
     * Don't forget to update your database before updating the databox.
     * Update behaviour:
     * Notice that in every case, the update only happens when the key
     * on the client does exist.
     * Otherwise, the client will ignore or convert it to an
     * insert when potentiallyInsert is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * @param properties
     * @param options
     */
    partialUpdate(properties: Partial<V>, options?: IfOption & PotentialInsertOption): R;
}
interface BundleArrInsertFunction<V, R> {
    /**
     * Inserts a new value in the selected array or keyArray.
     * Don't forget to update your database before updating the databox.
     * Notice that in every case, the insert only happens when the key
     * does not exist on the client.
     * Otherwise, the client will ignore or convert it to an
     * update when potentiallyUpdate is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * KeyArray -> Inserts the value at the end with the key.
     * But if you are using a compare function, it will insert the value in the correct position.
     * Array -> Key will be parsed to int if it is a number, then it will be inserted at the index.
     * Otherwise, it is possible to insert at the end with the key "$nextIndex".
     * @param key
     * @param value
     * @param options
     */
    insert(key: string | number | '$nextIndex', value: V, options?: IfOption & PotentialUpdateOption): R;
}
interface BundleObjInsertFunction<O extends object, R> {
    /**
     * Inserts a new value in the object.
     * Don't forget to update your database before updating the databox.
     * Notice that in every case, the insert only happens when the key
     * does not exist on the client.
     * Otherwise, the client will ignore or convert it to an
     * update when potentiallyUpdate is active.
     * Other conditions are that the timeout is newer than the existing
     * timeout and all if conditions are true.
     * @param property
     * @param value
     * @param options
     */
    insert<K extends OptionalObjectKeys<O>>(property: K, value: O[K], options?: IfOption & PotentialUpdateOption): R;
}
interface CommitFunction<R> {
    /**
     * @description
     * Apply all changes on the Databox.
     * Don't forget to update your database before updating the databox.
     */
    commit(options?: TimestampOption & ComplexTypesOption & InfoOption): R;
}
export declare type ContentPrimitive = null | boolean | string | number | Function;
declare type ContentBody<R, D, DE extends boolean> = (true extends DE ? DeleteFunction<ContentHead<R>> : {}) & (IsStrictlyAny<D> extends true ? UpdateFunction<any, ContentHead<any>> & ObjInsertFunction<any, ContentHead<any>> & FilterFunctions<any, any, ContentBody<any, any, true>> & {
    [p: string]: ContentBody<any, any, true>;
} : [
    D
] extends [ContentPrimitive] ? UpdateFunction<D, ContentHead<R>> : D extends Array<infer U> ? Omit<{
    [Index in keyof D]: ContentBody<R, D[Index], true>;
}, keyof typeof Array['prototype']> & Record<string, ContentBody<R, U, true>> & UpdateFunction<D, ContentHead<R>> & ArrInsertFunction<U, ContentHead<R>> & FilterFunctions<keyof D, U, ContentBody<R, U, true>> : D extends object ? {
    [K in keyof D]-?: ContentBody<R, RequiredValue<D[K]>, undefined extends D[K] ? true : false>;
} & UpdateFunction<D, ContentHead<R>> & ObjInsertFunction<D, ContentHead<R>> & FilterFunctions<keyof D, ObjectValues<D>, ContentBody<R, ObjectValues<D>, false>> : {});
declare type ContentHead<T> = ContentBody<T, RequiredValue<T>, undefined extends T ? true : false>;
declare type BundleContentBody<R, D, DE extends boolean> = (true extends DE ? BundleDeleteFunction<BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> : {}) & (IsStrictlyAny<D> extends true ? BundleUpdateFunction<any, BundleContentHead<any> & CommitFunction<BundleContentHead<any>>> & BundleObjInsertFunction<any, BundleContentHead<any> & CommitFunction<BundleContentHead<any>>> & BundleObjPartialUpdateFunction<any, BundleContentHead<any> & CommitFunction<BundleContentHead<any>>> & FilterFunctions<any, any, BundleContentBody<any, any, true>> & {
    [p: string]: BundleContentBody<any, any, true>;
} : [
    D
] extends [ContentPrimitive] ? BundleUpdateFunction<D, BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> : D extends Array<infer U> ? Omit<{
    [Index in keyof D]: BundleContentBody<R, D[Index], true>;
}, keyof typeof Array['prototype']> & Record<string, BundleContentBody<R, U, true>> & BundleUpdateFunction<D, BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> & BundleArrInsertFunction<U, BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> & FilterFunctions<keyof D, U, BundleContentBody<R, U, true>> : D extends object ? {
    [K in keyof D]-?: BundleContentBody<R, RequiredValue<D[K]>, undefined extends D[K] ? true : false>;
} & BundleUpdateFunction<D, BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> & BundleObjInsertFunction<D, BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> & BundleObjPartialUpdateFunction<D, BundleContentHead<R> & CommitFunction<BundleContentHead<R>>> & FilterFunctions<keyof D, ObjectValues<D>, BundleContentBody<R, ObjectValues<D>, false>> : {});
declare type BundleContentHead<T> = CommitFunction<BundleContentHead<T>> & BundleContentBody<T, RequiredValue<T>, undefined extends T ? true : false>;
export declare type Content<T, B extends boolean = false> = true extends B ? BundleContentHead<T> : ContentHead<T>;
export declare type DbContent<T extends Databox | StaticDatabox> = T extends Databox<infer D> ? ContentHead<D> : T extends StaticDatabox<infer D> ? ContentHead<D> : never;
export declare type DbContentBundle<T extends Databox | StaticDatabox> = T extends Databox<infer D> ? BundleContentHead<D> : T extends StaticDatabox<infer D> ? BundleContentHead<D> : never;
export declare type StaticDbContentAPI<T> = <B extends boolean = false>(bundle?: B) => Content<T, B>;
export declare type DbContentAPI<T, M> = <B extends boolean = false>(member: M, bundle?: B) => Content<T, B>;
export interface DataboxContentCompatible<M> {
}
export interface StaticDataboxContentCompatible {
}
export declare function buildStaticDbContentAPI<T>(databox: StaticDataboxContentCompatible): StaticDbContentAPI<T>;
export declare function buildDbContentAPI<T, M>(databox: DataboxContentCompatible<M>): DbContentAPI<T, M>;
export {};