import mongoose, { Schema } from 'mongoose';
import { Response, NextFunction, RequestHandler, Router } from 'express';
import { A as AccessRouterBaseRequest, aj as GuardHook, aI as ModelRequest, d8 as AccessRuntime, V as DataRouterOptions, T as DataRequest, d9 as DataService, a4 as ExtendedDataRouterOptions, a8 as Filter, b2 as Projection, c0 as Sort, a$ as Populate, aJ as ModelRouterOptions, da as Service, db as PublicService, aS as ModelVirtualRecordAccess, aO as ModelVirtualDescriptor, aQ as ModelVirtualGetter, aR as ModelVirtualLeaf, a6 as ExtendedModelRouterOptions, cL as Validation, bQ as RootRouterOptions, dc as OpenApiRouterOptions, dd as OpenApiRegistryOptions, de as OpenApiRouteDescriptor, df as OpenApiDocumentOptions, dg as OpenApiParameter, dh as OpenApiSchema, di as OpenApiResponses, ah as GlobalOptions, Z as DefaultModelRouterOptions, a5 as ExtendedDefaultModelRouterOptions } from './parsers-DhUuvj9B.mjs';
export { dj as AccessRouterPermissionMap, dk as AccessRouterPermissions, c as AccessRouterRequest, d as AccessRouterRequestExtensions, l as AjvErrorObjectLike, n as AjvValidatorLike, o as ArkTypeErrorsLike, p as ArkTypeLike, a7 as FieldOperationAccess, ai as GlobalPermissionValue, am as IoTsContextEntryLike, an as IoTsDecodeErrorLike, ao as IoTsDecoderLike, ap as JoiSchemaLike, aq as JoiValidationErrorDetailLike, aw as MaybePromise, ax as ModelBaseFilterHook, az as ModelDeleteHook, aA as ModelDocPermissionsHook, aC as ModelDocumentHook, aD as ModelHook, aF as ModelIdentifierHook, aG as ModelListHook, aH as ModelOverrideFilterHook, aK as ModelValidateHook, aL as ModelVirtualAccess, aM as ModelVirtualAccessRecord, aN as ModelVirtualContext, aP as ModelVirtualDoc, aT as ModelVirtuals, dl as OpenApiMethod, aU as OperationAccess, aX as PairedRouteAccess, a_ as PermissionSchema, dm as Permissions, bk as RequestSchemaAdapter, bl as RequestSchemaFailure, bm as RequestSchemaIssue, bn as RequestSchemaLike, bo as RequestSchemaOptions, bp as RequestSchemaResult, bq as RequestSchemaSuccess, br as RequestSchemaValidator, bT as RouteBaseAccess, bU as RouteGuardAccess, bV as RouteVariant, bW as RouteVariantAccess, c2 as StandardSchemaFailure, c3 as StandardSchemaInferOutput, c4 as StandardSchemaIssue, c5 as StandardSchemaPathSegment, c6 as StandardSchemaResult, c7 as StandardSchemaSuccess, c8 as StandardSchemaV1, cb as SubOperationAccess, cf as SubRouteGuardOptions, cr as SuperstructFailureLike, cs as SuperstructValidateLike, cF as ValibotIssueLike, cG as ValibotPathItemLike, cH as ValibotSafeParseLike, cI as ValibotSafeParseResult, cN as VineValidationErrorLike, cO as VineValidationMessageLike, cP as VineValidatorLike, cQ as VirtualSubModel, cR as WithVirtuals, cS as YupSchemaLike, cT as YupValidationErrorLike, dn as defaultRuntime, cU as defineRequestSchema, cV as fromAjv, cW as fromArkType, cX as fromIoTs, cY as fromJoi, cZ as fromStandardSchema, c_ as fromSuperstruct, c$ as fromValibot, d0 as fromVine, d1 as fromYup, d2 as fromZod } from './parsers-DhUuvj9B.mjs';
import JsonRouter from '@web-ts-toolkit/express-json-router';
import 'zod';

declare function macl(): (req: AccessRouterBaseRequest, res: Response, next: NextFunction) => Promise<void>;
interface GuardModelConditionID {
    type: 'param' | 'query';
    key: string;
}
interface GuardModelCondition {
    modelName: string;
    id: string | GuardModelConditionID;
    condition: string | string[];
}
declare function guard(condition: string): RequestHandler;
declare function guard(conditions: string[]): RequestHandler;
declare function guard(conditionFunc: GuardHook<ModelRequest>): RequestHandler;
declare function guard(modelCondition: GuardModelCondition): RequestHandler;

type SetTargetOption$1<TRouter, TOption> = {
    (option: TOption): TRouter;
    (key: string, option: unknown): TRouter;
};
declare class DataRouter<TData = unknown> {
    readonly runtime: AccessRuntime;
    readonly dataName: string;
    readonly router: JsonRouter;
    /** Frozen construction-time snapshot. Read current policy with runtime.getDataOptions(dataName). */
    readonly options: DataRouterOptions<TData>;
    readonly fullBasePath: string;
    constructor(dataName: string, initialOptions: DataRouterOptions<TData>, runtime?: AccessRuntime);
    private getRequestSchema;
    getService(req: DataRequest): DataService<TData>;
    private assertAllowed;
    private registerOpenApiRoute;
    private setCollectionRoutes;
    private setDocumentRoutes;
    /**
     * Update live behavior with a typed key/path or an options object. Dotted paths
     * such as `operationAccess.basicRead` update one key; object assignment replaces
     * supplied top-level values shallowly. The construction-time options snapshot stays fixed.
     */
    set<K extends keyof ExtendedDataRouterOptions<TData>>(key: K, value: ExtendedDataRouterOptions<TData>[K]): this;
    set(options: DataRouterOptions<TData>): this;
    /** Set one live option/path; `setOption('operationAccess.basicRead', undefined)` restores inheritance. */
    setOption<K extends keyof ExtendedDataRouterOptions<TData>>(key: K, option: ExtendedDataRouterOptions<TData>[K]): this;
    /** Shallowly replace supplied top-level options; an operationAccess object replaces that entire rule object. */
    setOptions(options: DataRouterOptions<TData>): this;
    data: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['data']>;
    listHardLimit: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['listHardLimit']>;
    /** Base-operation field grants; basic/advanced route guards belong to operationAccess. */
    permissionSchema: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['permissionSchema']>;
    /**
     * Live list/read guards plus basicList/advancedList/basicRead/advancedRead.
     * `operationAccess('basicRead', false)` updates one key and denies GET /:id
     * (and HEAD) with HTTP 401; registered POST reads still inherit `read`.
     * `operationAccess({ list: true, read: true })` replaces the whole rule object,
     * not a deep merge. Use setOption with undefined to restore variant inheritance.
     */
    operationAccess: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['operationAccess']>;
    baseFilter: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['baseFilter']>;
    /**
     * Trusted filter replacements applied before base-filter composition.
     * They may replace ordinary filters, but cannot replace an existing `false` denial.
     * Returning `false` denies the transaction.
     */
    overrideFilter: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['overrideFilter']>;
    decorate: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['decorate']>;
    decorateAll: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['decorateAll']>;
    idField: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['idField']>;
    resolveIdFilter: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['resolveIdFilter']>;
    queryRouteSegment: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['queryRouteSegment']>;
    get routes(): Router;
}

interface FindProps {
    filter: Filter;
    select?: Projection;
    sort?: Sort;
    populate?: Populate[] | string;
    limit?: string | number;
    hardLimit?: number;
    skip?: string | number;
    lean?: boolean;
}
interface FindOneProps {
    filter: Filter;
    select?: Projection;
    sort?: Sort;
    populate?: Populate[] | string;
    lean?: boolean;
}
declare class Model {
    modelName: string;
    mongooseModel: mongoose.Model<any>;
    runtime: AccessRuntime | null;
    constructor(modelName: string, runtime?: AccessRuntime);
    new(): any;
    create(data: unknown): Promise<any>;
    find({ filter, select, sort, populate, limit, hardLimit, skip, lean }: FindProps): mongoose.Query<any[], any>;
    findOne({ filter, select, sort, populate, lean }: FindOneProps): mongoose.Query<any, any>;
    exists(filter: Filter): ReturnType<typeof Model.prototype.findOne> | null;
    countDocuments(filter?: {}): mongoose.Query<number, any>;
    /** Cast a copy using this model's query schema/setters, without executing query middleware or persistence. */
    castFilter(filter: Record<string, unknown>): Record<string, unknown>;
    distinct(field: string, conditions?: {}): mongoose.Query<any[], any>;
    aggregate(pipeline: unknown[]): mongoose.Aggregate<any[]>;
}

type SetTargetOption<TRouter, TOption> = {
    (option: TOption): TRouter;
    (key: string, option: unknown): TRouter;
};
declare class ModelRouter<TModel = unknown, TVirtuals extends object = Record<never, never>> {
    readonly runtime: AccessRuntime;
    readonly modelName: string;
    readonly router: JsonRouter;
    readonly model: Model;
    /** Frozen construction-time snapshot. Read current policy with runtime.getModelOptions(modelName). */
    readonly options: ModelRouterOptions<TModel, TVirtuals>;
    readonly fullBasePath: string;
    constructor(modelName: string, initialOptions: ModelRouterOptions<TModel, TVirtuals>, runtime?: AccessRuntime);
    static fromModel<TModel, TVirtuals extends object = Record<never, never>>(model: mongoose.Model<TModel>, initialOptions: ModelRouterOptions<TModel, TVirtuals>, runtime?: AccessRuntime): ModelRouter<TModel, TVirtuals>;
    private getRequestSchema;
    getService(req: ModelRequest): Service<TModel, TVirtuals>;
    getPublicService(req: ModelRequest): PublicService<TModel, TVirtuals>;
    private assertAllowed;
    private registerOpenApiRoute;
    private setCollectionRoutes;
    private setDocumentRoutes;
    private setSubDocumentRoutes;
    private logEndpoints;
    /**
     * Update live behavior with a typed key/path or an options object. Dotted paths
     * such as `operationAccess.basicRead` update one key; object assignment replaces
     * supplied top-level values shallowly. The construction-time options snapshot stays fixed.
     */
    set<K extends Extract<keyof TVirtuals, string> & string, A extends ModelVirtualRecordAccess>(key: `virtuals.${K}.${A}`, value: ModelVirtualDescriptor<TModel, K extends keyof TVirtuals ? TVirtuals[K] : unknown> | ModelVirtualGetter<TModel, K extends keyof TVirtuals ? TVirtuals[K] : unknown>): this;
    set<K extends Extract<keyof TVirtuals, string> & string>(key: `virtuals.${K}`, value: ModelVirtualLeaf<TModel, K extends keyof TVirtuals ? TVirtuals[K] : unknown>): this;
    set<K extends keyof ExtendedModelRouterOptions<TModel, TVirtuals>>(key: K, value: ExtendedModelRouterOptions<TModel, TVirtuals>[K]): this;
    set(options: ModelRouterOptions<TModel, TVirtuals>): this;
    /** Set one live option/path; `setOption('operationAccess.basicRead', undefined)` restores inheritance. */
    setOption<K extends keyof ExtendedModelRouterOptions<TModel, TVirtuals>>(key: K, option: ExtendedModelRouterOptions<TModel, TVirtuals>[K]): this;
    /** Shallowly replace supplied top-level options; an operationAccess object replaces that entire rule object. */
    setOptions(options: ModelRouterOptions<TModel, TVirtuals>): this;
    /**
     * The maximum limit of the number of documents returned from the `list` operation.
     */
    listHardLimit: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['listHardLimit']>;
    /**
     * The object schema to define the access control policy for each model field.
     * Virtual permission keys (`fullAddress`, etc.) are typed via `TVirtuals`.
     * Basic/advanced route guards belong to operationAccess, not field-rule objects.
     */
    permissionSchema: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['permissionSchema']>;
    /**
     * Package-level computed fields (VIRT-01, VIRT-00A D1-D8).
     * Mutable post-construction (not a build-time key). Supports
     * `virtuals({...})`, `virtuals(name, descriptor)`, and dotted
     * `set('virtuals.<name>.<access>', descriptor)` forms. Exact →
     * `.default` → bare resolution applies; inapplicable registered names stay
     * virtual. Configuration is validated before commit against the receiving
     * Mongoose schema + child scopes, protected permission-field overlaps,
     * `_id`/reserved paths, and dotted names; rejected mutations preserve the
     * previous valid configuration.
     *
     * Reachable from the root (`@web-ts-toolkit/access-router`) and the
     * existing `./advanced` interface barrel; no new subpaths. Selected
     * virtual outputs are optional (`Partial`) because authorization, absent
     * dependencies, `undefined`, and fail-closed errors can omit them.
     *
     * @example Shortest typed happy-path (persisted model lacks `fullAddress`):
     * ```ts
     * import acl from '@web-ts-toolkit/access-router';
     * interface User { name: string; address: string; }
     * interface UserVirtuals { fullAddress: string; }
     * const router = acl.createRouter<User, UserVirtuals>('User', {
     *   permissionSchema: {
     *     name: { read: true },
     *     address: { read: 'canViewAddress' },
     *     fullAddress: { read: 'canViewAddress' },
     *   },
     *   virtuals: {
     *     fullAddress: {
     *       dependsOn: ['address'],
     *       read: async function (doc) {
     *         if (doc.address === undefined) return undefined;
     *         return `addr:${doc.address}`;
     *       },
     *     },
     *   },
     * });
     * router.virtuals({
     *   fullAddress: {
     *     dependsOn: ['address'],
     *     read: async function (doc) {
     *       if (doc.address === undefined) return undefined;
     *       return `addr:${doc.address}`;
     *     },
     *   },
     * });
     * router.set('virtuals.fullAddress.read', {
     *   get: async function (doc) {
     *     if (doc.address === undefined) return undefined;
     *     return `addr:${doc.address}`;
     *   },
     *   dependsOn: ['address'],
     * });
     * void router;
     * ```
     */
    virtuals: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['virtuals']>;
    /**
     * The object field to store the document permissions.
     */
    documentPermissionField: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['documentPermissionField']>;
    /**
     * The model fields always selected for ACL and response shaping.
     */
    alwaysSelectFields: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['alwaysSelectFields']>;
    /**
     * The function called in the process of generating document permissions.
     */
    docPermissions: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['docPermissions']>;
    /**
     * Configure live base and basic/advanced route guards. Only undefined inherits;
     * selected false denies with HTTP 401 without removing routes or OpenAPI entries.
     * `operationAccess('basicRead', false)` updates one key, and
     * `operationAccess('subs.comments.basicRead', false)` updates a field-specific key.
     * `operationAccess({ list: true, read: true })` replaces the whole rule object,
     * not a deep merge. Use setOption with undefined to restore variant inheritance.
     */
    operationAccess: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['operationAccess']>;
    /**
     * The base filter definitions applied in every query transaction.
     * @operation `list`, `read`, `update`, `delete`
     */
    baseFilter: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['baseFilter']>;
    /**
     * Trusted filter replacements applied before base-filter composition.
     * They may replace ordinary filters, but cannot replace an existing `false` denial.
     * Returning `false` denies the transaction.
     * @operation `list`, `read`, `update`, `delete`
     */
    overrideFilter: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['overrideFilter']>;
    /**
     * Hook
     *
     * The function called before a new/update document data is processed in `prepare` hooks. This method is used to validate `write data` and throw an error if not valid.
     * @operation `create`, `update`
     */
    validate: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['validate']>;
    /**
     * Hook
     *
     * The function called before a new document is created or an existing document is updated. This method is used to process raw data passed into the API endpoints.
     * @operation `create`, `update`
     */
    prepare: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['prepare']>;
    /**
     * Hook
     *
     * The function called before an updated document is saved.
     * @operation `update`
     */
    transform: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['transform']>;
    /**
     * Hook
     *
     * The function called after a new document is created or an updated document is saved.
     * @operation `create`, `update`
     */
    afterPersist: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['afterPersist']>;
    /**
     * Hook
     *
     * The function called after an updated document changes have been finalized.
     * @operation `update`
     */
    onChange: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['onChange']>;
    /**
     * Hook
     *
     * The function called before a document is deleted.
     * @operation `delete`
     */
    beforeDelete: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['beforeDelete']>;
    /**
     * Hook
     *
     * The function called after a document is deleted.
     * @operation `delete`
     */
    afterDelete: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['afterDelete']>;
    /**
     * Hook
     *
     * The function called before response data is sent. This method is used to process raw data to apply custom logic before sending the result.
     * @operation `list`, `read`, `create`, `update`
     */
    decorate: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['decorate']>;
    /**
     * Hook
     *
     * The functions are called before response data is sent and after `decorate` hooks run. This method is used to process and filter multiple document objects before sending the result.
     * @operation `list`
     */
    decorateAll: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['decorateAll']>;
    /**
     * The field matched against the `id` route param.
     * @operation `read`, `update`, `delete`
     */
    idField: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['idField']>;
    /**
     * The function used to resolve the `id` route param into a document filter.
     * @operation `read`, `update`, `delete`
     */
    resolveIdFilter: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['resolveIdFilter']>;
    /**
     * The route segment used for advanced query endpoints.
     */
    queryRouteSegment: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['queryRouteSegment']>;
    /**
     * The route segment used for advanced mutation endpoints.
     */
    mutationRouteSegment: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['mutationRouteSegment']>;
    /**
     * The default values used when missing in the operations.
     */
    defaults: SetTargetOption<ModelRouter<TModel, TVirtuals>, ModelRouterOptions<TModel, TVirtuals>['defaults']>;
    get routes(): Router;
}

declare class RootRouter {
    readonly runtime: AccessRuntime;
    router: JsonRouter;
    basename: string;
    operationAccess: Validation;
    maxBatchEntries: number;
    maxOrderGroups: number;
    maxConcurrentOperations: number;
    private readonly modelOperations;
    private readonly dataOperations;
    constructor(options?: RootRouterOptions, runtime?: AccessRuntime);
    private registerOpenApiRoute;
    private wrapResult;
    private hasTarget;
    private isAllowed;
    private processOp;
    private groupItemsByOrder;
    private normalizePositiveLimit;
    private validateBatch;
    private runGroup;
    private assertAllowed;
    private setRoutes;
    get routes(): Router;
}

declare function createOpenApiRouter(runtime: AccessRuntime, options?: OpenApiRouterOptions): Router;

declare class OpenApiRegistry {
    private readonly routes;
    private options;
    constructor(options?: OpenApiRegistryOptions);
    register(route: OpenApiRouteDescriptor): void;
    private assertOperationIdAvailable;
    getRoutes(): OpenApiRouteDescriptor[];
    clear(): void;
    setStrictMode(enabled: boolean): void;
    getSpec(info: OpenApiDocumentOptions): {
        openapi: string;
        info: Omit<OpenApiDocumentOptions, "servers">;
        servers?: OpenApiDocumentOptions["servers"];
        paths: Record<string, Record<string, {
            [key: `x-${string}`]: unknown;
            operationId?: string;
            summary?: string;
            description?: string;
            tags?: string[];
            deprecated?: boolean;
            parameters?: OpenApiParameter[];
            requestBody?: {
                required?: boolean;
                content: Record<string, {
                    schema: OpenApiSchema;
                }>;
            };
            responses: OpenApiResponses;
        }>>;
    };
    snapshot(): {
        routes: OpenApiRouteDescriptor[];
        options: Required<OpenApiRegistryOptions>;
    };
    restore(snapshot: {
        routes: OpenApiRouteDescriptor[];
        options: Required<OpenApiRegistryOptions>;
    }): void;
}

type AccessRouterInstance = ModelRouter<any> | DataRouter<any> | RootRouter;
type CombinedRouteInput = Router | AccessRouterInstance;
declare function combineRoutes(...inputs: CombinedRouteInput[]): Router;

declare class OpenApiCollisionError extends Error {
    readonly collisionKind: 'path' | 'operationId';
    readonly method?: string;
    readonly path?: string;
    readonly operationId?: string;
    readonly existing?: unknown;
    readonly incoming?: unknown;
    constructor(message: string, details: {
        collisionKind: 'path' | 'operationId';
        method?: string;
        path?: string;
        operationId?: string;
        existing?: unknown;
        incoming?: unknown;
    });
}

declare const setGlobalOptions: (options: GlobalOptions) => void;
declare const setGlobalOption: <K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]) => void;
declare const getGlobalOptions: () => GlobalOptions;
declare const getGlobalOption: <K extends keyof GlobalOptions>(key: K, defaultValue?: GlobalOptions[K]) => GlobalOptions[K];

declare const setModelOptions: <TModel = unknown, TVirtuals extends object = Record<never, never>>(modelName: string, options: ModelRouterOptions<TModel, TVirtuals>) => void;
declare const setModelOption: <K extends keyof ExtendedModelRouterOptions<TModel, TVirtuals>, TModel = unknown, TVirtuals extends object = Record<never, never>>(modelName: string, key: K, value: ExtendedModelRouterOptions<TModel, TVirtuals>[K]) => void;
declare const getModelOptions: <TModel = unknown, TVirtuals extends object = Record<never, never>>(modelName: string) => ModelRouterOptions<TModel, TVirtuals>;
declare const getModelOption: <K extends keyof ExtendedModelRouterOptions<TModel, TVirtuals>, TModel = unknown, TVirtuals extends object = Record<never, never>>(modelName: string, key: K | string, defaultValue?: ExtendedModelRouterOptions<TModel, TVirtuals>[K]) => ExtendedModelRouterOptions<TModel, TVirtuals>[K];
declare const getModelNames: () => string[];
declare const getModelJsonSchema: (modelName: string) => Record<string, unknown>;
declare const registerModelInstance: <TModel>(modelName: string, model: mongoose.Model<TModel>) => void;
declare const hasModelInstance: (modelName: string) => boolean;
declare const getModelInstance: <TModel = unknown>(modelName: string) => mongoose.Model<TModel> | null;

declare const setDefaultModelOptions: (options: DefaultModelRouterOptions) => void;
declare const setDefaultModelOption: <K extends keyof ExtendedDefaultModelRouterOptions>(key: K, value: ExtendedDefaultModelRouterOptions[K]) => void;
declare const getDefaultModelOptions: () => DefaultModelRouterOptions<unknown>;
declare const getDefaultModelOption: <K extends keyof ExtendedDefaultModelRouterOptions>(key: K, defaultValue?: ExtendedDefaultModelRouterOptions[K]) => ExtendedDefaultModelRouterOptions<unknown>[K];

interface Options {
    virtualPermissionField?: string;
    modelName: string;
}
declare function permissionsPlugin(schema: Schema, options: Options): void;

type LogLevel = 'debug' | 'info' | 'warn' | 'error';
declare const redactFilter: <T>(filter: T) => T;
declare const redactPayload: <T>(payload: T) => T;
declare const safeStringify: (value: unknown) => string;
declare const isLevelEnabled: (level: LogLevel) => boolean;
interface OpLogContext {
    op: string;
    modelName?: string;
    dataName?: string;
    populateCount?: number;
    selectCount?: number;
    page?: number;
    pageSize?: number;
    skip?: number;
    limit?: number;
    sort?: unknown;
    filterKeyValueCount?: number;
    startedAt?: number;
    durationMs?: number;
    resultCode?: string | number;
}

type CreateRouter = {
    <TModel, TVirtuals extends object = Record<never, never>>(model: mongoose.Model<TModel>, options: ModelRouterOptions<TModel, TVirtuals>): ModelRouter<TModel, TVirtuals>;
    <TModel, TVirtuals extends object = Record<never, never>>(modelName: string, options: ModelRouterOptions<TModel, TVirtuals>): ModelRouter<TModel, TVirtuals>;
    (options: RootRouterOptions): RootRouter;
};
type CreateDataRouter = {
    <TData>(dataName: string, options: DataRouterOptions<TData>): DataRouter<TData>;
};
type CreateRuntimeOpenApiRouter = (options?: OpenApiRouterOptions) => Router;
type WttSet = {
    <K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]): void;
    (options: {
        [K in keyof GlobalOptions]: GlobalOptions[K];
    }): void;
};
interface Wtt {
    runtime: AccessRuntime;
    createRouter: CreateRouter;
    createDataRouter: CreateDataRouter;
    createOpenApiRouter: CreateRuntimeOpenApiRouter;
    combineRoutes: typeof combineRoutes;
    set: WttSet;
    setGlobalOptions: typeof setGlobalOptions;
    setGlobalOption: typeof setGlobalOption;
    getGlobalOptions: typeof getGlobalOptions;
    getGlobalOption: typeof getGlobalOption;
    setModelOptions: typeof setModelOptions;
    setModelOption: typeof setModelOption;
    getModelOptions: typeof getModelOptions;
    getModelOption: typeof getModelOption;
    getModelNames: typeof getModelNames;
    getModelJsonSchema: typeof getModelJsonSchema;
    setDefaultModelOptions: typeof setDefaultModelOptions;
    setDefaultModelOption: typeof setDefaultModelOption;
    getDefaultModelOptions: typeof getDefaultModelOptions;
    getDefaultModelOption: typeof getDefaultModelOption;
    registerModelInstance: <TModel>(modelName: string, model: mongoose.Model<TModel>) => void;
    hasModelInstance: (modelName: string) => boolean;
    getModelInstance: <TModel = unknown>(modelName: string) => mongoose.Model<TModel> | null;
    RootRouter: typeof RootRouter;
    ModelRouter: typeof ModelRouter;
    DataRouter: typeof DataRouter;
}
type AccessRuntimeApi = typeof macl & Wtt;
declare function createAccessRuntime(): AccessRuntimeApi;
declare const acl: AccessRuntimeApi;

export { AccessRuntime, type AccessRuntimeApi, type CombinedRouteInput, DataRouter, DataRouterOptions, DefaultModelRouterOptions, ExtendedDataRouterOptions, ExtendedDefaultModelRouterOptions, ExtendedModelRouterOptions, GlobalOptions, GuardHook, type GuardModelCondition, type GuardModelConditionID, ModelRouter, ModelRouterOptions, ModelVirtualDescriptor, ModelVirtualGetter, ModelVirtualLeaf, ModelVirtualRecordAccess, type OpLogContext, OpenApiCollisionError, OpenApiDocumentOptions, OpenApiRegistry, OpenApiRegistryOptions, OpenApiRouteDescriptor, OpenApiRouterOptions, RootRouter, RootRouterOptions, Validation, acl, combineRoutes, createAccessRuntime, createOpenApiRouter, acl as default, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelInstance, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, hasModelInstance, isLevelEnabled, permissionsPlugin, redactFilter, redactPayload, registerModelInstance, safeStringify, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions };