import { QueryDocumentSnapshot } from 'firebase-admin/firestore';
import { Observable, ReplaySubject } from 'rxjs';
import * as i0 from '@angular/core';
import * as dayjs from 'dayjs';
import dayjs__default from 'dayjs';
import * as _nx_ddd_firestore from '@nx-ddd/firestore';
import Dexie from 'dexie';
import { Repository } from '@nx-ddd/common/domain';

type DocumentData = {
    [field: string]: any;
};
interface GetOptions {
    readonly source?: 'default' | 'server' | 'cache';
}
interface DocumentChangeAction<T> {
    type: any;
    payload: {
        doc: DocumentSnapshot<T>;
    };
}
interface DocumentSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
    id: string;
    ref: {
        path: string;
    };
    data: () => AppModelType | undefined;
    get: (fieldPath: string) => any;
    exists?: (() => boolean) | boolean;
}
interface QuerySnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
    docs: Array<QueryDocumentSnapshot<AppModelType, DbModelType>>;
}
interface Timestamp {
    readonly seconds: number;
    readonly nanoseconds: number;
    toDate(): Date;
    toMillis(): number;
    isEqual(other: Timestamp): boolean;
    valueOf(): string;
}
interface TimestampConstructor {
    new (seconds: number, nanoseconds: number): Timestamp;
    now(): Timestamp;
    fromDate(date: Date): Timestamp;
    fromMillis(milliseconds: number): Timestamp;
}
type FieldValue = any;
type ToFirestoreData<Entity, Date> = {
    [K in keyof Entity]: Entity[K] extends Date ? Timestamp | FieldValue : Entity[K];
};
interface DocumentReference<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> {
    __ref?: Origin;
    exists(): Promise<boolean>;
    set(data: AppModelType, options?: any): Promise<void | any>;
    get(): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
    update(data: AppModelType): Promise<void | any>;
    delete(): Promise<void | any>;
    stateChanges?: () => Observable<DocumentSnapshot<AppModelType, DbModelType>>;
}
type CollectionReference<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> = Query<AppModelType, DbModelType, Origin>;
type CollectionGroup<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> = Query<AppModelType, DbModelType, Origin>;
interface Query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> {
    __ref?: Origin;
    stateChanges?: () => Observable<DocumentChangeAction<DocumentData>[]>;
    get(options?: GetOptions): Promise<QuerySnapshot<AppModelType, DbModelType>>;
    onSnapshot?(onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void): () => void;
    count(): Promise<number>;
}
type CollectionLike<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> = CollectionReference<AppModelType, DbModelType, Origin> | CollectionGroup<AppModelType, DbModelType, Origin> | Query<AppModelType, DbModelType, Origin>;

declare class DateAdapter {
    isDate<D>(value: any): value is D;
    isValid(value: any): boolean;
    getJsDate<D>(value: any): D;
    convertToDate<D>(value: Date): D;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateAdapter>;
}

type QueryFn<AppModelType, DbModelType, R> = (collection?: any) => R;
type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'in' | 'array-contains-any' | 'not-in';
declare abstract class FirestoreAdapter<Date = any> {
    protected dateAdapter: DateAdapter;
    protected abstract isTimestamp(v: any): v is Timestamp;
    protected abstract isFieldValue(v: any): v is FieldValue;
    abstract get Timestamp(): any;
    abstract get FieldValue(): any;
    abstract get FieldPath(): any;
    abstract doc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(path: string): DocumentReference<AppModelType>;
    abstract collection<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(path: string): CollectionReference<AppModelType, DbModelType>;
    abstract collectionGroup<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collectionId: string): CollectionGroup<AppModelType, DbModelType>;
    abstract query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collection: CollectionReference<AppModelType, DbModelType>, ...queryFnArray: QueryFn<AppModelType, DbModelType, any>[]): Query<AppModelType, DbModelType>;
    abstract where<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(key: string, evaluation: WhereFilterOp, value: unknown): QueryFn<AppModelType, DbModelType, any>;
    abstract orderBy<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(key: string, order: 'asc' | 'desc'): QueryFn<AppModelType, DbModelType, any>;
    abstract limit<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(n: number): QueryFn<AppModelType, DbModelType, any>;
    abstract runTransaction(fn: any): any;
    abstract batch(): any;
    toFirestoreData<Entity>(entity: Entity): ToFirestoreData<Entity, Date>;
    fromFirestoreData<Entity>(data: ToFirestoreData<Entity, Date>): Entity;
    toFirestore<T>(obj: object, Entity: new () => T): object;
    fromFirestore<T = any>(data: any, Entity: new () => T): T;
    /**
     * @description FirestoreのUpdateは通常のオブジェクトでは孫以下のプロパティが既存データとマージされないので、パスに変換する必要がある。
     */
    flattenForUpdate(obj: any): any;
    convertDateToTimestamp(date: Date): Timestamp;
    convertTimestampToDate(timestamp: Timestamp): Date;
}
declare function provideFirestoreAdapter(useClass: new () => FirestoreAdapter): {
    provide: typeof FirestoreAdapter;
    useClass: new () => FirestoreAdapter;
};

interface IFirestoreConverter<E extends {
    id: string;
}> {
    fromFirestore(doc: DocumentSnapshot<object>): E;
    fromFirestoreMany(docs: DocumentSnapshot<object>[]): E[];
    toFirestore(entity: Partial<E>): object;
    fromObject?(obj: object): E;
    toObject?(entity: E): object;
}
declare function getConverter<Entity extends {
    id: string;
}>(Entity: new () => Entity, adapter?: FirestoreAdapter): IFirestoreConverter<Entity>;
declare function injectConverter<Entity extends {
    id: string;
}>(Entity: new () => Entity): IFirestoreConverter<Entity>;

type CollectionParamMap<Entity extends {
    id: string;
}> = Partial<Entity>;
type DocParamMap<Entity extends {
    id: string;
}> = CollectionParamMap<Entity> & Pick<Entity, 'id'>;
type ExtractParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
    [K in Param | keyof ExtractParams<Rest>]: string;
} : T extends `${infer _Start}:${infer Param}` ? {
    [K in Param]: string;
} : {};
type ColParam$3<T extends {
    readonly collectionPath: string;
}> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
type DocParam$2<T extends {
    readonly collectionPath: string;
}> = ColParam$3<T> & {
    id: string;
};
declare class FirestorePathBuilder<Entity extends {
    id: string;
}, Path extends string = string> {
    private paths;
    doc(param: DocParamMap<Entity>): string;
    collection(param?: Omit<ExtractParams<Path>, 'id'> | {}): string;
    collectionGroup(): string;
    constructor(paths: string[]);
}
declare function pathBuilderFactory<E extends {
    id: string;
}, Path extends string = string>(path: Path): FirestorePathBuilder<E, Path>;
declare function parsePath<Path extends string = string>(path: Path): string[];
declare const resolvePaths: (obj: object, paths: string[]) => string;

declare class FirestoreDAO<Entity extends {
    id: string;
}, FirestoreData = ToFirestoreData<Entity, dayjs__default.Dayjs>> {
    protected adapter: FirestoreAdapter;
    protected pathBuilder: FirestorePathBuilder<Entity>;
    constructor(adapter: FirestoreAdapter, pathBuilder: FirestorePathBuilder<Entity>);
    collection(paramMap?: Partial<Entity>): CollectionReference<FirestoreData>;
    collectionGroup(): CollectionGroup<FirestoreData>;
    doc(paramMap: Partial<Entity> & {
        id: string;
    }): DocumentReference<FirestoreData>;
    getCollection(paramMap?: Partial<Entity>): CollectionLike;
}

declare const FIRESTORE_ANNOTATIONS = "firestore_annotations";
type FirestoreFieldType = 'id' | 'boolean' | 'number' | 'timestamp' | 'string' | 'geopoint' | 'null' | 'map' | 'array' | 'reference';
interface FirestoreAnnotation {
    type: FirestoreFieldType;
    fieldName: string;
    propName: string;
    childType: any;
}
declare const createDecorator: (type: FirestoreFieldType, options?: {
    childType?: any;
}) => (nameOrProps?: {
    name?: string;
} | string) => (target: any, propName: string) => void;
declare const createPropsDecorator: (type: FirestoreFieldType, options?: {
    childType?: any;
}) => (nameOrProps?: {
    name?: string;
} | string) => (target: any, propName: string) => void;
declare const createClassDecorator: <Props extends {
    name: string;
}>(type: string) => (nameOrProps: Props | string) => (target: any) => void;
declare const getAnnotations: (target: any) => FirestoreAnnotation[];
/** @deprecated use getAnnotations */
declare function getFirestoreAnnotations(target: any): FirestoreAnnotation[];
declare function getCollection(target: any): string;
declare const Firestore: {
    Collection: (nameOrProps: string | {
        name: string;
    }) => (target: any) => void;
    ID: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    String: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    Null: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    Geopoint: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    Boolean: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    Timestamp: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    Number: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
    Map: (childType?: () => any, props?: {
        name?: string;
    }) => (target: any, propName: string) => void;
    Array: (childType?: () => any, props?: {
        name?: string;
    }) => (target: any, propName: string) => void;
    Reference: (nameOrProps?: {
        name?: string;
    } | string) => (target: any, propName: string) => void;
};

declare class FirestoreQuery$1<Entity extends {
    id: string;
} = any, FirestoreData = ToFirestoreData<Entity, dayjs__default.Dayjs>> extends FirestoreDAO<Entity, FirestoreData> {
    protected converter: IFirestoreConverter<Entity>;
    protected pathBuilder: FirestorePathBuilder<Entity>;
    constructor(adapter: FirestoreAdapter, converter: IFirestoreConverter<Entity>, pathBuilder: FirestorePathBuilder<Entity>);
    protected readonly collection$: ReplaySubject<CollectionLike<FirestoreData>>;
    protected readonly list$: Observable<Entity[]>;
    /** @deprecated */
    listChanges(paramMap?: Partial<Entity>, options?: {
        switch?: boolean;
    }): Observable<Entity[]>;
    listChangesV2(paramMap?: Partial<Entity>): Observable<Entity[]>;
    listChangesAfter(updatedAt: dayjs__default.Dayjs, { limit }?: {
        limit?: number;
    }): Observable<Entity[]>;
    changes({ id }: Partial<Entity>): Observable<Entity>;
    changesV2(params: Partial<Entity>): Observable<Entity>;
    get({ id }: Partial<Entity> & {
        id: string;
    }): Promise<Entity>;
    list(paramMap?: Partial<Entity>): Promise<Entity[]>;
    protected listChangesByCollectionRef(collection: CollectionReference<FirestoreData> | CollectionGroup<FirestoreData>): Observable<Entity[]>;
    protected switchCollectionRef(paramMap?: Partial<Entity>): void;
    switchCollection(collection: CollectionLike<any>): void;
}

type ColParam$2<T extends BaseFirestoreQuery<any>> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
type DocParam$1<T extends BaseFirestoreQuery<any>> = ColParam$2<T> & {
    id: string;
};
declare abstract class BaseFirestoreQuery<Entity extends {
    id: string;
} = any> {
    protected abstract readonly adapter: FirestoreAdapter;
    protected abstract readonly converter: IFirestoreConverter<Entity>;
    abstract readonly collectionPath: string;
    protected abstract pathBuilder: FirestorePathBuilder<Entity, typeof this.collectionPath>;
    protected abstract dao: FirestoreDAO<Entity>;
    count(paramMap?: ColParam$2<this>): Promise<number>;
    changes(params: DocParam$1<this>): Observable<Entity>;
    get(paramMap: DocParam$1<this>): Promise<Entity>;
    list(paramMap?: ColParam$2<this>): Promise<Entity[]>;
    listChanges(paramMap?: ColParam$2<this>): Observable<Entity[]>;
    protected getChanges$ByDocument(doc: DocumentReference): Observable<Entity>;
    protected getListChanges$ByCollectionLike(collection: CollectionLike): Observable<Entity[]>;
}
declare abstract class FirestoreQuery<Entity extends {
    id: string;
} = any> extends BaseFirestoreQuery<Entity> {
    protected readonly adapter: FirestoreAdapter<any>;
    abstract readonly collectionPath: string;
    protected abstract readonly converter: IFirestoreConverter<Entity>;
    get pathBuilder(): FirestorePathBuilder<Entity, typeof this.collectionPath>;
    protected get dao(): FirestoreDAO<Entity, _nx_ddd_firestore.ToFirestoreData<Entity, dayjs.Dayjs>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreQuery<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreQuery<any>>;
}
declare function getFirestoreQuery<Entity extends {
    id: string;
}>(entity: {
    new (): Entity;
}, adapter?: FirestoreAdapter): BaseFirestoreQuery<Entity>;
declare function injectFirestoreQuery<Entity extends {
    id: string;
}>(entity: {
    new (): Entity;
}): BaseFirestoreQuery<Entity>;

type ColParam$1<T extends {
    readonly collectionPath: string;
}> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
interface EntityData {
    id: string;
    value: string;
    collectionPath: string;
    updatedAt: string;
}
declare class DexieAdapter<E extends {
    id: string;
    updatedAt: dayjs__default.Dayjs;
}> extends Dexie {
    entities: Dexie.Table<EntityData, string>;
    constructor();
    count$(): Observable<number>;
    getLastUpdatedAt$(collectionPath: string): Observable<dayjs__default.Dayjs>;
    bulkPut(collectionPath: string, entities: E[]): Promise<string>;
    listChanges(collectionPath: string): Observable<E[]>;
}
declare class FirestoreIndexedDbCached<E extends {
    id: string;
    updatedAt: dayjs__default.Dayjs;
}> {
    protected collectionPath: string;
    constructor(collectionPath: string);
    readonly adapter: DexieAdapter<E>;
    getLastUpdatedAt$(): Observable<dayjs__default.Dayjs>;
    setMany(entities: E[]): Promise<string>;
    listChanges(): Observable<E[]>;
}
declare abstract class CachedFirestoreQuery<E extends {
    id: string;
    updatedAt: dayjs__default.Dayjs;
} = any> extends FirestoreQuery<E> {
    protected _cached: FirestoreIndexedDbCached<E>;
    protected get cached(): FirestoreIndexedDbCached<E>;
    protected readonly config: {
        throttleTime: number;
        loadChunkSize: number;
    };
    listChanges(paramMap?: ColParam$1<this>): Observable<E[]>;
    protected _listChange(paramMap?: ColParam$1<this>): Observable<E[]>;
    protected _listChangesAfter(collection: CollectionLike, updatedAt: dayjs__default.Dayjs, { limit }?: {
        limit?: number;
    }): Observable<E[]>;
    progressChanges(): Observable<{
        cloud: number;
        local: number;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CachedFirestoreQuery<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CachedFirestoreQuery<any>>;
}

type ExtractEntity<T extends BaseFirestoreRepository<any, any>> = T extends BaseFirestoreRepository<infer Entity, any> ? Entity : never;
type ColParam<T extends BaseFirestoreRepository<any, any>> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
type DocParam<T extends BaseFirestoreRepository<any, any>, TExtra = {}> = ColParam<T> & {
    id: string;
} & TExtra;
declare abstract class BaseFirestoreRepository<Entity extends {
    id: string;
}, TExtraParams = {}> extends Repository<Entity> {
    abstract readonly collectionPath: string;
    protected abstract readonly adapter: FirestoreAdapter;
    protected abstract converter: IFirestoreConverter<Entity>;
    abstract readonly pathBuilder: FirestorePathBuilder<Entity, typeof this.collectionPath>;
    list(paramMap?: ColParam<this>, query?: any): Promise<Entity[]>;
    listChanges(): Observable<Entity[]>;
    count(paramMap?: ColParam<this>): Promise<number>;
    get(paramMap?: DocParam<this, TExtraParams>): Promise<Entity>;
    save(entity: DocParam<this, TExtraParams> & Entity): Promise<[Entity, boolean]>;
    saveMany(entities: Entity[]): Promise<void>;
    create(entity: DocParam<this, TExtraParams> & Entity): Promise<Entity>;
    createMany(entities: (DocParam<this, TExtraParams> & Entity)[]): Promise<Entity[]>;
    update(entity: DocParam<this, TExtraParams> & Partial<Entity>): Promise<void>;
    updateMany(data: Partial<Entity>[]): Promise<void>;
    delete(paramMap: DocParam<this, TExtraParams>): Promise<void>;
    deleteMany(params: {
        id: string;
    }[]): Promise<number>;
    deleteAll(): Promise<void>;
    bulkWrite(entities: (DocParam<this, TExtraParams> & Entity)[], timestamps?: string[]): Promise<void>;
    bulkCreate(entities: (DocParam<this, TExtraParams> & Entity)[]): Promise<void>;
    bulkUpdate(entities: (DocParam<this, TExtraParams> & Partial<Entity>)[]): Promise<void>;
    bulkDelete(paramMaps: DocParam<this, TExtraParams>[]): Promise<void>;
    protected collection(paramMap?: Omit<ExtractParams<typeof this.collectionPath>, 'id'>): CollectionReference<object>;
    protected collectionGroup(): CollectionGroup<object>;
    protected doc(paramMap: DocParam<this, TExtraParams>): DocumentReference<object>;
    protected genId: () => string;
    protected _list(collection: CollectionReference<object>): Promise<Entity[]>;
    protected _get(doc: DocumentReference<object>): Promise<Entity>;
    protected _save(doc: DocumentReference<object>, entity: Entity): Promise<[Entity, boolean]>;
    protected _create(doc: DocumentReference<object>, entity: Entity): Promise<Entity>;
    protected _set(doc: DocumentReference<object>, entity: Partial<Entity>, isUpdate?: boolean): Promise<DocumentSnapshot<object, _nx_ddd_firestore.DocumentData>>;
    protected buildServerTimestampObject(keys?: string[]): {};
}
declare abstract class FirestoreRepository<Entity extends {
    id: string;
}, TExtraParams = {}> extends BaseFirestoreRepository<Entity, TExtraParams> {
    protected readonly adapter: FirestoreAdapter<any>;
    get pathBuilder(): FirestorePathBuilder<Entity, typeof this.collectionPath>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreRepository<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreRepository<any, any>>;
}
declare function getFirestoreRepository<Entity extends {
    id: string;
}, TExtraParams = {}>(entity: {
    new (): Entity;
}, adapter?: FirestoreAdapter): BaseFirestoreRepository<Entity, TExtraParams>;
declare function injectFirestoreRepository<Entity extends {
    id: string;
}, TExtraParams = {}>(entity: {
    new (): Entity;
}): BaseFirestoreRepository<Entity, TExtraParams>;

export { BaseFirestoreQuery, BaseFirestoreRepository, CachedFirestoreQuery, FIRESTORE_ANNOTATIONS, Firestore, FirestoreAdapter, FirestoreDAO, FirestorePathBuilder, FirestoreQuery$1 as FirestoreQuery, FirestoreQuery as FirestoreQueryV2, FirestoreRepository, createClassDecorator, createDecorator, createPropsDecorator, getAnnotations, getCollection, getConverter, getFirestoreAnnotations, getFirestoreQuery, getFirestoreRepository, injectConverter, injectFirestoreQuery, injectFirestoreRepository, parsePath, pathBuilderFactory, provideFirestoreAdapter, resolvePaths };
export type { ColParam$3 as ColParam, CollectionGroup, CollectionLike, CollectionReference, DocParam$2 as DocParam, DocumentChangeAction, DocumentData, DocumentReference, DocumentSnapshot, ExtractEntity, ExtractParams, FieldValue, FirestoreAnnotation, FirestoreFieldType, GetOptions, IFirestoreConverter, Query, QueryFn, QuerySnapshot, Timestamp, TimestampConstructor, ToFirestoreData, WhereFilterOp };