import { Facade } from '@noeldemartin/utils';
import { MockInstance } from 'vitest';

declare interface Engine {
    create(collection: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collection: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collection: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collection: string, id: string): Promise<void>;
}

declare type EngineAttributeFilter = EngineAttributeValue | {
    $eq: EngineAttributeValue;
} | {
    $or: EngineAttributeFilter[];
} | {
    $in: EngineAttributeLeafValue[];
} | {
    $contains: EngineAttributeFilter | EngineAttributeFilter[];
};

declare type EngineAttributeLeafValue = string | number | boolean | null | Date;

declare type EngineAttributeUpdate = EngineAttributeValue | EngineAttributeUpdateMap | EngineAttributeUpdateOperation | {
    $apply: EngineAttributeUpdateOperation[];
};

declare interface EngineAttributeUpdateMap extends Record<string, EngineAttributeUpdate> {
}

declare type EngineAttributeUpdateOperation = {
    $update: EngineAttributeUpdate;
} | {
    $updateItems: EngineUpdateItemsOperatorData | EngineUpdateItemsOperatorData[];
} | {
    $unset: string | string[] | true;
} | {
    $push: EngineAttributeValue;
};

declare type EngineAttributeValue = EngineAttributeLeafValue | EngineAttributeValueMap | EngineAttributeValueArray | EngineAttributeValueArrayMap;

declare interface EngineAttributeValueArray extends Array<EngineAttributeValue> {
}

declare interface EngineAttributeValueArrayMap extends Array<Record<string, EngineAttributeValue>> {
}

declare interface EngineAttributeValueMap extends Record<string, EngineAttributeValue> {
}

declare type EngineDocument = Record<string, EngineAttributeValue>;

declare type EngineDocumentsCollection = Record<string, EngineDocument>;

declare type EngineFilters = EngineRootFilter & Record<string, EngineAttributeFilter>;

declare interface EngineRootFilter {
    $in?: (string | number | Record<string, string | number>)[];
}

declare interface EngineUpdateItemsOperatorData {
    $where?: EngineFilters;
    $update?: EngineAttributeUpdate;
    $override?: EngineAttributeValueMap;
    $unset?: true;
}

declare type EngineUpdates = Record<string, EngineAttributeUpdate> | {
    $unset: string | string[];
} | {
    $overwrite: EngineAttributeValue;
};

export declare const FakeEngine: Facade<FakeEngineInstance>;

export declare interface FakeEngineCollection {
    [id: string]: EngineDocument;
}

export declare interface FakeEngineDatabase {
    [collection: string]: FakeEngineCollection;
}

export declare class FakeEngineInstance implements Engine {
    database: FakeEngineDatabase;
    readonly createSpy: MockInstance;
    readonly readOneSpy: MockInstance;
    readonly readManySpy: MockInstance;
    readonly updateSpy: MockInstance;
    readonly deleteSpy: MockInstance;
    private helper;
    constructor();
    use(): void;
    resetSpies(): void;
    create(collectionName: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collectionName: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collectionName: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collectionName: string, id: string): Promise<void>;
    private hasCollection;
    private collection;
}

export { }