import type { AdapterFlags, AllOperationKeys, EventIds, FlagsOf, ObserverFilter, PersistenceObservable, PersistenceObserver } from "../persistence/types";
import { Context } from "../persistence/Context";
import { ContextualArgs, ContextualizedArgs, ContextualLoggedClass, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass";
import { Constructor } from "@decaf-ts/decoration";
import type { Observer } from "../interfaces/Observer";
import { ObserverHandler } from "../persistence/ObserverHandler";
export declare abstract class Service<C extends Context<AdapterFlags> = Context<AdapterFlags>> extends ContextualLoggedClass<C> implements PersistenceObservable<C>, PersistenceObserver<C> {
    readonly name?: string | undefined;
    protected observers: Observer[];
    protected observerHandler?: ObserverHandler;
    protected constructor(name?: string | undefined);
    /**
     * @description Registers an observer for this repository.
     * @summary Adds an observer that will be notified of changes to models in this repository.
     * @param {Observer} observer - The observer to register.
     * @param {ObserverFilter} [filter] - Optional filter to limit which events the observer receives.
     * @return {void}
     * @see {Observable#observe}
     */
    observe(observer: Observer, filter?: ObserverFilter): void;
    /**
     * @description Unregisters an observer from this repository.
     * @summary Removes an observer so it will no longer receive notifications of changes.
     * @param {Observer} observer - The observer to unregister.
     * @return {void}
     * @throws {InternalError} If the observer handler is not initialized.
     * @see {Observable#unObserve}
     */
    unObserve(observer: Observer): void;
    /**
     * @description Notifies all observers of an event.
     * @summary Updates all registered observers with information about a database event.
     * @param {string} table - The table name where the event occurred.
     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
     * @param {EventIds} id - The ID or IDs of the affected records.
     * @param {...any[]} args - Additional arguments.
     * @return {Promise<void>} A promise that resolves when all observers have been notified.
     * @throws {InternalError} If the observer handler is not initialized.
     */
    updateObservers(table: Constructor<any> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<C>): Promise<void>;
    /**
     * @description Creates repository flags for an operation
     * @summary Generates a set of flags that describe a database operation, combining default flags with overrides
     * @template F - The Repository Flags type
     * @template M - The model type
     * @param {OperationKeys} operation - The type of operation being performed
     * @param {Partial<F>} flags - Custom flag overrides
     * @param {...any[]} args - Additional arguments
     * @return {Promise<F>} The complete set of flags
     */
    protected flags(operation: string, flags: Partial<FlagsOf<C>>, ...args: any[]): Promise<FlagsOf<C>>;
    /**
     * @description Alias for updateObservers.
     * @summary Notifies all observers of an event (alias for updateObservers).
     * @param {string} table - The table name where the event occurred.
     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
     * @param {EventIds} id - The ID or IDs of the affected records.
     * @param {...any[]} args - Additional arguments.
     * @return {Promise<void>} A promise that resolves when all observers have been notified.
     */
    refresh(table: Constructor<any> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<C>): Promise<void>;
    /**
     * @description The context constructor for this adapter
     * @summary Reference to the context class constructor used by this adapter
     */
    protected readonly Context: Constructor<C>;
    context(operation: ((...args: any[]) => any) | string, overrides: Partial<FlagsOf<C>>, ...args: MaybeContextualArg<Context<any>>): Promise<C>;
    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<CONTEXT>>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<CONTEXT>>): Promise<ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>>;
    /**
     * @description Retrieves a Service instance by name/class
     * @summary Looks up and returns a cached API instance by its name or constructor
     * @template A Type extending Api
     * @param {string | Constructor<A>} name - Name of the API or its constructor
     * @return {A} The requested API instance
     */
    static get<A extends Service>(name: string | symbol | Constructor<A>): A;
    static boot<C extends Context<any> = any>(...args: MaybeContextualArg<C>): Promise<void>;
}
export declare abstract class ClientBasedService<CLIENT, CONF, C extends Context<any> = any> extends Service {
    protected _client?: CLIENT;
    protected _config?: CONF;
    protected constructor();
    boot(...args: MaybeContextualArg<C>): Promise<void>;
    abstract initialize(...args: ContextualArgs<C>): Promise<{
        config: CONF;
        client: CLIENT;
    }>;
    protected get config(): CONF;
    get client(): CLIENT;
    shutdown(...args: MaybeContextualArg<C>): Promise<void>;
}