import { Server, Socket } from "socket.io";
import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
import { Constructor, IsData, LoggersType, IAutoUpdatedClientObject, EventEmitter3, MongoId, IAutoUpdateManager, DEMErrorCode, EntityDescriptor, LazyLoadingOptions } from "./CommonTypes.js";
import { BeAnObject, ReturnModelType } from "@typegoose/typegoose/lib/types";
import { Paths } from "./CommonTypes.js";
import { AutoUpdatedClientObject } from "./AutoUpdatedClientObjectClass.js";
import { ServerChangeTracker, ServerDeltaSyncOptions } from "./sync/index.js";
export type WrappedInstances<T extends Record<string, IAutoUpdatedClientObject<any>>> = {
    [K in keyof T]: AutoUpdateServerManager<T[K]>;
};
export type AUSDefinitions<T extends Record<string, IAutoUpdatedClientObject<any>>> = {
    [K in keyof T]: ServerManagerDefinition<T[K], T>;
};
export type EventMiddlewareFunction<T extends Record<string, IAutoUpdatedClientObject<any>>, C extends IAutoUpdatedClientObject<any>> = (event: DEMEvent<C>, managers: WrappedInstances<T>, socket: Socket) => Promise<void>;
export type StartupMiddlewareFunction<T extends Record<string, IAutoUpdatedClientObject<any>>, C extends IAutoUpdatedClientObject<any>> = (ids: C[], managers: WrappedInstances<T>, socket: Socket) => Promise<C[]>;
export type AccessMiddleware<T extends Record<string, IAutoUpdatedClientObject<any>>, C extends IAutoUpdatedClientObject<any>> = {
    eventMiddleware?: EventMiddlewareFunction<T, C>;
    startupMiddleware?: StartupMiddlewareFunction<T, C>;
};
export type AUSOption<C extends IAutoUpdatedClientObject<any>, T extends Record<string, IAutoUpdatedClientObject<any>>> = {
    accessDefinitions?: AccessMiddleware<T, C>;
    onUpdate?: (obj: C, set: (key: Paths<C, AutoUpdatedClientObject<any>>, val: any) => Promise<{
        success: boolean;
        msg: string;
    }>, key: Paths<C, AutoUpdatedClientObject<any>>) => Promise<void>;
    onDeletion?: (obj: C) => Promise<void>;
    deltaSync?: boolean | ServerDeltaSyncOptions;
    lazyLoading?: boolean | LazyLoadingOptions;
};
export type ServerManagerDefinition<C extends IAutoUpdatedClientObject<any>, T extends Record<string, IAutoUpdatedClientObject<any>>> = {
    class: Constructor<C>;
    options?: AUSOption<C, T>;
};
export type BaseManagers = Record<string, IAutoUpdateManager<any>>;
export declare enum DEMEventTypes {
    "new" = "new",
    "update" = "update",
    "delete" = "delete",
    "get" = "get",
    "startup" = "startup"
}
export type DEMEvent<C extends IAutoUpdatedClientObject<any>> = {
    type: DEMEventTypes.delete | DEMEventTypes.get;
    manager: IAutoUpdateManager<C>;
    object: C;
    data: never;
} | {
    type: DEMEventTypes.update;
    manager: IAutoUpdateManager<C>;
    object: C;
    data: {
        _id: string;
        key: string;
        value: unknown;
    };
} | {
    type: DEMEventTypes.startup;
    manager: IAutoUpdateManager<C>;
    object: never;
    data: never;
} | {
    type: DEMEventTypes.new;
    manager: IAutoUpdateManager<C>;
    object: never;
    data: Omit<IsData<C>, "_id">;
};
/**
 * Configures event whitelisting and permission middleware for the Socket.IO server.
 *
 * @param socket_server - Socket.IO server instance.
 * @param loggers - Logging interfaces.
 * @param managers - Registry of server managers.
 * @param _models - Optional models registry.
 */
export declare function setupSocketMiddleware(socket_server: Server, loggers: LoggersType, managers: BaseManagers, _models?: unknown): void;
/**
 * Inspects database readiness states across all configured server managers.
 *
 * @param managers - Registry of server managers to inspect.
 * @param loggers - Optional logger callbacks.
 * @param emitter - Optional event emitter for error events.
 * @throws {DEMError} Throws DEMErrorCode.DB_NOT_CONNECTED if any database is disconnected.
 */
export declare function checkServerDbStates(managers: Record<string, AutoUpdateServerManager<any>>, loggers?: LoggersType, emitter?: EventEmitter3): void;
/**
 * Initializes and starts all server managers, executes DB state assertions, preloads data, and attaches sockets.
 *
 * @param defs - Server manager definitions including class constructors and options.
 * @param loggers_ - Loggers interface.
 * @param socket - Socket.IO server instance.
 * @param doDebug - Flag indicating whether debug logging is enabled.
 * @param emitter - Shared event emitter.
 * @param models - Optional model registry.
 * @returns Promise resolving to the map of initialized server managers.
 */
export declare function AUSManagerFactory<T extends Record<string, IAutoUpdatedClientObject<any>>>(defs: AUSDefinitions<T>, loggers_: LoggersType, socket: Server, doDebug?: boolean, emitter?: EventEmitter3, models?: unknown): Promise<WrappedInstances<T>>;
export declare class AutoUpdateServerManager<T extends IAutoUpdatedClientObject<T>, M extends Record<string, IAutoUpdateManager<any>> = any> extends AutoUpdateManager<T, M> {
    readonly model: ReturnModelType<any, BeAnObject>;
    readonly clientSockets: Set<Socket<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>>;
    private readonly knownObjectIdsBySocket;
    readonly options?: AUSOption<T, Record<string, IAutoUpdatedClientObject<any>>>;
    protected objects_: {
        [_id: string]: T;
    };
    readonly managers: M;
    startupPayloadCache: {
        ids: string[];
        objects?: any[];
        properties: string[];
    } | null;
    private _cachedObjectsArray;
    readonly changeTracker?: ServerChangeTracker;
    /**
     * Initializes an AutoUpdateServerManager instance.
     *
     * @param classParam - Target server object class constructor.
     * @param className - Managed entity class name.
     * @param socket - Socket.IO Server instance.
     * @param loggers - Logger callbacks interface.
     * @param model - Typegoose Mongoose model for database operations.
     * @param managers - Sibling server managers registry.
     * @param emitter - Shared event emitter.
     * @param options - Server manager options including access middlewares and delta sync settings.
     */
    constructor(classParam: Constructor<T>, className: string, socket: Server, loggers: LoggersType, model: ReturnModelType<any, BeAnObject>, managers: M, emitter: EventEmitter3, options?: AUSOption<T, Record<string, IAutoUpdatedClientObject<any>>>);
    /**
     * Inspects current database connection state.
     *
     * @returns Object describing connected flag, numeric readyState, and stateName.
     */
    checkDbState(): {
        connected: boolean;
        readyState: number;
        stateName: string;
    };
    /**
     * Verifies database connection is active.
     *
     * @throws {DEMError} Throws DEMErrorCode.DB_NOT_CONNECTED if database is not connected.
     */
    assertDbConnected(): void;
    /**
     * Preloads all database documents into memory for the manager class.
     *
     * @param options - Optional batch loading options.
     * @returns Promise resolving when all entities are loaded and populated in globalCache.
     */
    preLoad(options?: {
        batchSize?: number;
    }): Promise<void>;
    /**
     * Resolves back-references and pointers across loaded objects.
     *
     * @returns Promise resolving when reference resolution completes.
     */
    loadReferences(): Promise<void>;
    /**
     * Phase 1 of reference loading: initial reference resolution on all entities.
     * Includes back-references (createdWithParent) and queued parent changes.
     * Run this only after all managers have finished preLoad, so that all objects exist in globalCache.
     *
     * @returns Promise resolving when phase 1 completes for all entities of this manager.
     */
    loadInitialReferences(): Promise<void>;
    /**
     * Phase 2 of reference loading: resolves missing pointers and marks the manager as loaded.
     *
     * @returns Promise resolving when phase 2 completes for all entities of this manager.
     */
    loadPointerReferences(): Promise<void>;
    /**
     * Indicates whether smart lazy loading mode is enabled for this manager.
     *
     * @returns True if lazy loading is enabled.
     */
    get isLazyLoadingEnabled(): boolean;
    /**
     * Generates an array of entity descriptors for unhydrated startup payloads.
     *
     * @param objects - Collection of server entity instances.
     * @returns Array containing entity descriptors with unique identifiers and human-readable summaries.
     */
    generateManifest(objects: T[]): EntityDescriptor[];
    /**
     * Recursively traverses and collects referenced entity documents up to a maximum depth.
     * Uses an ID set to prevent infinite cycles.
     *
     * @param rootObj - The initial server entity instance.
     * @param maxDepth - Maximum reference graph traversal depth.
     * @returns Dictionary mapping manager class names to arrays of extracted entity data.
     */
    collectEntityGraph(rootObj: T, maxDepth: number): Record<string, any[]>;
    /**
     * Asynchronously traverses entity references to collect a graph of related entities,
     * querying MongoDB for unhydrated entities when lazy loading is active.
     *
     * @param rootObj - Root entity to start traversal from.
     * @param maxDepth - Maximum reference depth to traverse.
     * @returns Promise resolving to dictionary mapping manager class names to arrays of extracted entity data.
     */
    collectEntityGraphAsync(rootObj: T, maxDepth: number): Promise<Record<string, any[]>>;
    /**
     * Registers a client socket with the manager and binds startup, delete, and new event listeners.
     *
     * @param socket - Connected client Socket instance.
     */
    registerSocket(socket: Socket): void;
    /**
     * Emits standardized deauthenticate event to a target client socket or all connected client sockets,
     * triggering automatic teardown and memory cleanup on the client.
     *
     * @param targetSocket - Optional client socket to deauthenticate. If omitted, all registered client sockets are deauthenticated.
     * @param reason - Optional explanation for deauthentication.
     */
    deauthenticate(targetSocket?: Socket, reason?: string): void;
    /**
     * Retrieves a server managed object by identifier.
     *
     * @param _id - Optional entity identifier.
     * @returns Managed entity instance, null, or undefined.
     */
    getObject(_id?: MongoId): T | null | undefined;
    /**
     * Dictionary of all managed entities keyed by their string IDs.
     *
     * @returns Map of managed entities.
     */
    get objects(): Record<string, T>;
    /**
     * Array representation of all managed entities.
     *
     * @returns Array containing all managed entities.
     */
    get objectsAsArray(): T[];
    /**
     * Deletes an entity from database, manager cache, and mutation tracker.
     *
     * @param _id - Identifier of entity to delete.
     * @returns Promise resolving to deletion outcome object.
     */
    deleteObject(_id: MongoId, isRemote?: boolean): Promise<{
        success: boolean;
        message: string;
        code?: DEMErrorCode;
    }>;
    private pendingMissingFetches;
    /**
     * Retrieves an entity missing from memory by querying MongoDB directly.
     *
     * @param _id - Identifier of missing entity.
     * @returns Promise resolving to the retrieved server object.
     * @throws {DEMError} Throws DEMErrorCode.DOCUMENT_NOT_FOUND or MANAGERS_NOT_INITIALIZED.
     */
    handleGetMissingObject(_id: MongoId): Promise<T>;
    /**
     * Generates creation payload for client broadcasts, returning an entity descriptor in lazy mode.
     *
     * @param object - Server entity instance.
     * @returns Entity ID string or descriptor payload.
     */
    getNewObjectPayload(object: any): string | EntityDescriptor;
    /**
     * Creates a new entity document in MongoDB and instantiates its manager wrapper.
     * Broadcasts creation event to client sockets with authorized access.
     *
     * @param data - Initial entity properties.
     * @returns Promise resolving to the created server entity.
     * @throws {DEMError} Throws DEMErrorCode.MANAGERS_NOT_INITIALIZED.
     */
    createObject(data: Omit<IsData<T>, "_id">): Promise<T>;
    /**
     * Re-evaluates client socket permissions against dynamic startup middleware rules.
     * Emits 'new' or 'delete' socket events when client access changes dynamically.
     *
     * @param object - Entity to evaluate.
     */
    checkPermissionBoundaries(object: T): Promise<void>;
}