import { ConfigService } from '@nestjs/config';
import { Observable } from 'rxjs';
import { S as SmpEnvironmentVariables, a as SmpWinstonLoggerService } from './smp-winston-logger-service.class-CltMrgeM.js';
import { S as SmpCacheInterceptorStrategy } from './smp-cache-interceptor-strategy.class-CMO0pOJC.js';
import { Timestamp, Firestore, DocumentData, Query } from 'firebase-admin/firestore';
import { App, ServiceAccount } from 'firebase-admin/app';
import { SmpBaseJwtTokenPlain } from '@tonysamperi/ts-mapi-core';
import { DynamicModule, ModuleMetadata } from '@nestjs/common';
import 'zod';
import 'url';
import '@tonysamperi/logger';
import 'winston';
import 'winston-transport';
import '@tonysamperi/ts-mapi-core/rxjs';

type SmpFirestorePlainCacheDocument = Pick<SmpFirestoreCacheDocument, "createdOn" | "expiry" | "key" | "value">;
type SmpFirestoreMappedCacheDocument = Pick<SmpFirestoreCacheDocument, "createdOn" | "key" | "value"> & {
    expiry: Timestamp | undefined;
};
declare class SmpFirestoreCacheDocument<T = any> {
    get createdOn(): number;
    get expiry(): number | undefined;
    get key(): string;
    get value(): T;
    protected _createdOn: number;
    protected _expiry?: number;
    protected _key: string;
    protected _value: T;
    constructor(key: string, value: T, ttl?: number);
    static fromFirestoreDocument(doc: SmpFirestoreMappedCacheDocument): SmpFirestoreCacheDocument;
    static fromPlain(plain: SmpFirestorePlainCacheDocument): SmpFirestoreCacheDocument;
    /**
     * Converts the instance to a Firestore-compatible document object
     */
    toFirestoreDocument(): SmpFirestoreMappedCacheDocument;
    /**
     * Converts the instance to a plain object with expiry a number
     */
    toPlain(): SmpFirestorePlainCacheDocument;
}

/**
 * This provider is meant to be used with the SmpCacheInterceptor. Don't use it directly unless you know what you're doing.
 * Note: we don't pass the ttl to the inner strategy, otherwise the value gets wrapped.
 * In firestore the expiry is part of the document, and the deletion is managed by Firebase automagically (by defining a TTL rule on the collection)
 */
declare class SmpCacheInterceptorFirestoreStrategy<T extends SmpEnvironmentVariables = SmpEnvironmentVariables> extends SmpCacheInterceptorStrategy {
    protected readonly _configSrv: ConfigService<T>;
    protected readonly _loggerSrv: SmpWinstonLoggerService;
    get collectionName(): string;
    private _firestoreSrv;
    constructor(_configSrv: ConfigService<T>, _loggerSrv: SmpWinstonLoggerService);
    removeByPrefix(prefix: string): Observable<void>;
    write<T = unknown>(key: string, value: T, ttl?: number): Observable<void>;
    protected _flushRaw(): Observable<void>;
    protected _readRaw(key: string): Observable<SmpFirestoreCacheDocument<any> | undefined>;
    protected _removeRaw(key: string): Observable<void>;
    protected _writeRaw(key: string, value: any, ttl?: number): Observable<void>;
}

/**
 * This is a base Firestore interface offered by the library.
 * It uses the Firestore API to read/write to Firestore
 * You can override the default values by defining them in your env files.
 * You can also pass a custom logger service to the SmpConfigModule.forRoot method. To not use this one.
 *
 * Call the _init method whenever you're ready
 */
declare abstract class SmpAbstractFirestoreService<T extends SmpEnvironmentVariables = SmpEnvironmentVariables> {
    protected readonly _configSrv: ConfigService<T>;
    protected readonly _loggerSrv: SmpWinstonLoggerService;
    protected _app: App;
    protected _appName: string;
    protected _collectionName: string;
    protected _db: Firestore;
    private _googleCredentials;
    constructor(_configSrv: ConfigService<T>, _loggerSrv: SmpWinstonLoggerService);
    protected _init(): void;
    protected _millisToTimestamp(millis: number): Timestamp;
    protected _send<T extends object = DocumentData>(query: Query): Observable<T[]>;
    protected _validateAccess(): Observable<{
        read: boolean;
        write: boolean;
    }>;
    private _checkReadAccess;
    private _checkWriteAccess;
    private _parseCredentials;
}

/**
 * This basically allow you to create a firestore token service with a few lines of code
 *
 * @example
 * ```ts
 * export class SmpFirestoreFooTokenService extends SmpAbstractFirestoreTokenService {
 *
 *     protected override _tokenKey: string = "foo";
 *
 *     // @ts-expect-error we're sure this will work
 *     override getToken() {
 *         return super.getToken<string>()
 *             .pipe(map((item) => {
 *                 (this.constructor as typeof SmpFirestoreFooTokenService).checkJwtToken(item);
 *
 *                 return item;
 *             }));
 *     }
 * }
 * ```
 *
 */
declare class SmpAbstractFirestoreTokenService<T extends SmpEnvironmentVariables = SmpEnvironmentVariables> extends SmpAbstractFirestoreService<T> {
    protected _appName: string;
    protected _collectionName: string;
    protected _tokenKey: string;
    constructor(configSrv: ConfigService<T>, loggerSrv: SmpWinstonLoggerService);
    /**
     * Decodes jwt token and throws if expired
     */
    checkJwtToken(t: string): void;
    createJwtToken<T extends SmpBaseJwtTokenPlain = SmpBaseJwtTokenPlain>(data: T): string;
    /**
     * Retrieve the full transaction from the transaction hash
     * Returns an Observable that emits the transaction string or an empty string if not found.
     */
    getToken<T = any>(): Observable<T>;
    putToken<T = any>(token: T): Observable<void>;
}

/**
 * This is a base GCP Storage interface offered by the library.
 * You can override the default values by defining them in your env files.
 * You can also pass a custom logger service to the SmpConfigModule.forRoot method. To not use this one.
 *
 * Call the _init method whenever you're ready
 */
declare abstract class SmpAbstractGcpStorageService<T extends SmpEnvironmentVariables = SmpEnvironmentVariables> {
    protected readonly _configSrv: ConfigService<T>;
    protected _app: App;
    protected _appName: string;
    private _googleCredentials;
    constructor(_configSrv: ConfigService<T>);
    getJsonObject<T>(bucketName: string, objectPath: string): Observable<T | null>;
    listObjectsByPrefix(bucketName: string, prefix: string): Observable<{
        name: string;
        updatedAt: string;
    }[]>;
    putGzipJsonObject(bucketName: string, objectPath: string, payload: unknown): Observable<void>;
    putJsonObject(bucketName: string, objectPath: string, payload: unknown): Observable<void>;
    protected _getJsonObjectFromGcs<T>(bucketName: string, objectPath: string): Promise<T | null>;
    protected _init(): void;
    protected _parseCredentials(): ServiceAccount;
    protected _saveObjectInGcs(bucketName: string, objectPath: string, body: Buffer, contentType: string, contentEncoding?: string): Promise<void>;
}

declare class SmpFirestoreCacheService<T extends SmpEnvironmentVariables = SmpEnvironmentVariables> extends SmpAbstractFirestoreService<T> {
    get collectionName(): string;
    protected _appName: string;
    protected _batchMaxSize: number;
    constructor(configSrv: ConfigService<T>, loggerSrv: SmpWinstonLoggerService, collectionName: string);
    flush(): Observable<void>;
    get(key: string): Observable<SmpFirestoreCacheDocument | undefined>;
    remove(key: string): Observable<void>;
    /**
     * Batch removes all cache documents where key starts with string
     * @param prefix
     */
    removeByPrefix(prefix: string): Observable<void>;
    set(data: SmpFirestoreCacheDocument): Observable<void>;
    protected _generateDocumentId(key: string): string;
}

declare const smpFirestoreModuleFeatures: {
    SmpCacheInterceptorFirestoreStrategy: {
        providers: {
            provide: typeof SmpCacheInterceptorStrategy;
            useClass: typeof SmpCacheInterceptorFirestoreStrategy;
        }[];
        exports: (typeof SmpCacheInterceptorStrategy)[];
    };
};
interface SmpFirestoreModuleOpts {
    features?: (keyof typeof smpFirestoreModuleFeatures)[];
}
declare class SmpFirestoreModule {
    private static _initialized;
    constructor();
    static forRoot(config?: Partial<SmpFirestoreModuleOpts>): DynamicModule;
    static forRootAsync(factory: () => Promise<Partial<SmpFirestoreModuleOpts>>): Promise<DynamicModule>;
    protected static _getDynamicConfig(features: (keyof typeof smpFirestoreModuleFeatures)[]): ModuleMetadata;
}

export { SmpAbstractFirestoreService, SmpAbstractFirestoreTokenService, SmpAbstractGcpStorageService, SmpCacheInterceptorFirestoreStrategy, SmpFirestoreCacheDocument, SmpFirestoreCacheService, type SmpFirestoreMappedCacheDocument, SmpFirestoreModule };