import mongoose, { Schema } from 'mongoose';
import { Response, NextFunction, RequestHandler, Router } from 'express';
import { ag as GlobalOptions, Z as DefaultModelRouterOptions, aI as ModelRouterOptions, V as DataRouterOptions, a5 as ExtendedDefaultModelRouterOptions, a6 as ExtendedModelRouterOptions, a4 as ExtendedDataRouterOptions, A as AccessRouterBaseRequest, ai as GuardHook, aH as ModelRequest, T as DataRequest, cR as DataService, a7 as Filter, aS as Projection, bN as Sort, aP as Populate, cS as Service, cT as PublicService, cu as Validation, bE as RootRouterOptions } from './parsers-DppKW-Fd.mjs';
export { cU as AccessRouterPermissionMap, cV as AccessRouterPermissions, c as AccessRouterRequest, d as AccessRouterRequestExtensions, l as AjvErrorObjectLike, n as AjvValidatorLike, o as ArkTypeErrorsLike, p as ArkTypeLike, ah as GlobalPermissionValue, al as IoTsContextEntryLike, am as IoTsDecodeErrorLike, an as IoTsDecoderLike, ao as JoiSchemaLike, ap as JoiValidationErrorDetailLike, av as MaybePromise, aw as ModelBaseFilterHook, ay as ModelDeleteHook, az as ModelDocPermissionsHook, aB as ModelDocumentHook, aC as ModelHook, aE as ModelIdentifierHook, aF as ModelListHook, aG as ModelOverrideFilterHook, aJ as ModelValidateHook, cW as Permissions, b8 as RequestSchemaAdapter, b9 as RequestSchemaFailure, ba as RequestSchemaIssue, bb as RequestSchemaLike, bc as RequestSchemaOptions, bd as RequestSchemaResult, be as RequestSchemaSuccess, bf as RequestSchemaValidator, bH as RouteGuardAccess, bP as StandardSchemaFailure, bQ as StandardSchemaInferOutput, bR as StandardSchemaIssue, bS as StandardSchemaPathSegment, bT as StandardSchemaResult, bU as StandardSchemaSuccess, bV as StandardSchemaV1, ca as SuperstructFailureLike, cb as SuperstructValidateLike, co as ValibotIssueLike, cp as ValibotPathItemLike, cq as ValibotSafeParseLike, cr as ValibotSafeParseResult, cw as VineValidationErrorLike, cx as VineValidationMessageLike, cy as VineValidatorLike, cz as YupSchemaLike, cA as YupValidationErrorLike, cB as defineRequestSchema, cC as fromAjv, cD as fromArkType, cE as fromIoTs, cF as fromJoi, cG as fromStandardSchema, cH as fromSuperstruct, cI as fromValibot, cJ as fromVine, cK as fromYup, cL as fromZod } from './parsers-DppKW-Fd.mjs';
import JsonRouter from '@web-ts-toolkit/express-json-router';
import 'zod';

type OpenApiMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
type OpenApiSchema = Record<string, unknown>;
type OpenApiSchemaSource = unknown;
type OpenApiParameter = {
    name: string;
    in: 'path' | 'query';
    required?: boolean;
    description?: string;
    schema?: OpenApiSchema;
};
type OpenApiResponse = {
    description: string;
    content?: Record<string, {
        schema: OpenApiSchema;
    }>;
};
type OpenApiResponses = Record<string, OpenApiResponse>;
type OpenApiRouteDescriptor = {
    method: OpenApiMethod;
    path: string;
    operationId?: string;
    summary?: string;
    description?: string;
    tags?: string[];
    acl?: string;
    deprecated?: boolean;
    query?: OpenApiSchemaSource;
    body?: OpenApiSchemaSource;
    pathParams?: Record<string, OpenApiSchemaSource>;
    responses?: OpenApiResponses;
    /**
     * When true, replaces an existing registration with the same method/path
     * even when the descriptors differ. When false (default), conflicting
     * registrations throw at registration time so consumers can detect
     * accidental route shadowing.
     */
    allowReplace?: boolean;
    /**
     * When true, this exact descriptor is idempotent and registering the same
     * method/path with an equivalent descriptor again is silently accepted.
     * Differing re-registrations still throw unless {@link allowReplace} is set.
     * Additionally, an idempotent descriptor may share its operationId with
     * another idempotent descriptor mounted at a different path on the same
     * registry, so reserved operations (e.g. the root batch route) can be
     * exposed from multiple base paths without triggering strict-mode
     * duplicate-operationId rejection.
     */
    idempotent?: boolean;
};
type OpenApiRegistryOptions = {
    /**
     * Throw when the same method/path is registered twice with differing
     * descriptors, instead of silently replacing. Default: true (strict).
     * The {@link AccessRuntime} registry is constructed in strict mode by
     * default; construct {@link OpenApiRegistry} directly with
     * `rejectConflicts: false` for legacy replacement semantics.
     */
    rejectConflicts?: boolean;
    /**
     * Throw when the same operationId is registered more than once, including
     * when {@link OpenApiRouteDescriptor.allowReplace} is set. Default: true.
     */
    rejectDuplicateOperationIds?: boolean;
};
type OpenApiDocumentOptions = {
    title: string;
    version: string;
    description?: string;
    servers?: Array<{
        url: string;
        description?: string;
    }>;
};
type OpenApiRouterOptions = Partial<OpenApiDocumentOptions> & {
    jsonPath?: string;
    docsPath?: string | false;
    swaggerUiCssUrl?: string;
    swaggerUiBundleUrl?: string;
};

type ModelReferenceMap = {
    [key: string]: string | ModelReferenceMap;
};
declare class AccessRuntime {
    private readonly allowGlobalModelLookup;
    constructor(options?: {
        allowGlobalModelLookup?: boolean;
    });
    private readonly globalOptions;
    private readonly defaultModelOptions;
    private readonly modelOptions;
    private readonly modelJsonSchemas;
    private readonly dataOptions;
    private readonly modelRefs;
    private readonly modelSubs;
    private readonly modelAtts;
    private readonly modelInstances;
    private readonly openApiRegistry;
    registerModelInstance<TModel>(modelName: string, model: mongoose.Model<TModel>): void;
    hasModelInstance(modelName: string): boolean;
    getModelInstance<TModel = unknown>(modelName: string): mongoose.Model<TModel> | null;
    registerOpenApiRoute(route: OpenApiRouteDescriptor): void;
    /**
     * Enable strict OpenAPI collision detection for the remainder of this
     * runtime's lifetime. After this call, conflicting method/path
     * registrations and duplicate operationIds throw {@link OpenApiCollisionError}
     * instead of silently replacing. Existing already-registered routes are
     * not retroactively re-validated.
     */
    enableOpenApiCollisionDetection(): void;
    getOpenApiRoutes(): OpenApiRouteDescriptor[];
    clearOpenApiRoutes(): void;
    getOpenApiSpec(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;
        }>>;
    };
    createBootstrapSnapshot(): {
        globalOptions: GlobalOptions;
        defaultModelOptions: DefaultModelRouterOptions;
        modelOptions: Record<string, ModelRouterOptions>;
        dataOptions: Record<string, DataRouterOptions>;
        modelInstances: Record<string, mongoose.Model<unknown>>;
        modelJsonSchemas: Record<string, Record<string, unknown>>;
        modelRefs: Record<string, ModelReferenceMap>;
        modelSubs: Record<string, string[]>;
        modelAtts: Record<string, string[]>;
        openApi: {
            routes: OpenApiRouteDescriptor[];
            options: Required<OpenApiRegistryOptions>;
        };
    };
    restoreBootstrapSnapshot(snapshot: ReturnType<AccessRuntime['createBootstrapSnapshot']>): void;
    setGlobalOptions(options: GlobalOptions): void;
    setGlobalOption<K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]): void;
    getGlobalOptions(): GlobalOptions;
    getGlobalOption<K extends keyof GlobalOptions>(key: K, defaultValue?: GlobalOptions[K]): GlobalOptions[K];
    setDefaultModelOptions(options: DefaultModelRouterOptions): void;
    setDefaultModelOption<K extends keyof ExtendedDefaultModelRouterOptions>(key: K, value: ExtendedDefaultModelRouterOptions[K]): void;
    getDefaultModelOptions(): DefaultModelRouterOptions<unknown>;
    getDefaultModelOption<K extends keyof ExtendedDefaultModelRouterOptions>(key: K, defaultValue?: ExtendedDefaultModelRouterOptions[K]): ExtendedDefaultModelRouterOptions<unknown>[K];
    private createModelOptions;
    private getOrCreateModelOptions;
    setModelOptions<TModel = unknown>(modelName: string, options: ModelRouterOptions<TModel>): void;
    setModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K, value: ExtendedModelRouterOptions<TModel>[K]): void;
    getModelOptions<TModel = unknown>(modelName: string): ModelRouterOptions<TModel>;
    getModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string, defaultValue?: ExtendedModelRouterOptions<TModel>[K]): ExtendedModelRouterOptions<TModel>[K];
    getExactModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string): ExtendedModelRouterOptions<TModel>[K];
    getModelNames(): string[];
    hasModel(modelName: string): boolean;
    getModelJsonSchema(modelName: string): Record<string, unknown>;
    private createDataOptions;
    private getOrCreateDataOptions;
    setDataOptions<TData = unknown>(dataName: string, options: DataRouterOptions<TData>): void;
    setDataOption<K extends keyof DataRouterOptions<TData>, TData = unknown>(dataName: string, key: K, value: DataRouterOptions<TData>[K]): void;
    getDataOptions<TData = unknown>(dataName: string): DataRouterOptions<TData>;
    getDataSnapshot<TData = unknown>(dataName: string): readonly TData[];
    getDataOption<K extends keyof DataRouterOptions<TData>, TData = unknown>(dataName: string, key: K | string, defaultValue?: DataRouterOptions<TData>[K]): DataRouterOptions<TData>[K];
    getExactDataOption<K extends keyof ExtendedDataRouterOptions<TData>, TData = unknown>(dataName: string, key: K | string): ExtendedDataRouterOptions<TData>[K];
    getDataNames(): string[];
    ensureModelMeta(modelName: string): void;
    getModelRef(modelName: string, refPath: string): string | null;
    getModelSub(modelName: string): string[];
    getModelAtt(modelName: string): string[];
}
declare const defaultRuntime: AccessRuntime;

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;
    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;
    set<K extends keyof DataRouterOptions<TData>>(key: K, value: DataRouterOptions<TData>[K]): this;
    set(options: DataRouterOptions<TData>): this;
    setOption<K extends keyof DataRouterOptions<TData>>(key: K, option: DataRouterOptions<TData>[K]): this;
    setOptions(options: DataRouterOptions<TData>): this;
    data: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['data']>;
    listHardLimit: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['listHardLimit']>;
    permissionSchema: SetTargetOption$1<DataRouter<TData>, DataRouterOptions<TData>['permissionSchema']>;
    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>;
    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> {
    readonly runtime: AccessRuntime;
    readonly modelName: string;
    readonly router: JsonRouter;
    readonly model: Model;
    readonly options: ModelRouterOptions<TModel>;
    readonly fullBasePath: string;
    constructor(modelName: string, initialOptions: ModelRouterOptions<TModel>, runtime?: AccessRuntime);
    static fromModel<TModel>(model: mongoose.Model<TModel>, initialOptions: ModelRouterOptions<TModel>, runtime?: AccessRuntime): ModelRouter<TModel>;
    private getRequestSchema;
    getService(req: ModelRequest): Service<TModel>;
    getPublicService(req: ModelRequest): PublicService<TModel>;
    private assertAllowed;
    private registerOpenApiRoute;
    private setCollectionRoutes;
    private setDocumentRoutes;
    private setSubDocumentRoutes;
    private logEndpoints;
    set<K extends keyof ExtendedModelRouterOptions<TModel>>(key: K, value: ExtendedModelRouterOptions<TModel>[K]): this;
    set(options: ModelRouterOptions<TModel>): this;
    setOption<K extends keyof ExtendedModelRouterOptions<TModel>>(key: K, option: ExtendedModelRouterOptions<TModel>[K]): this;
    setOptions(options: ModelRouterOptions<TModel>): this;
    /**
     * The maximum limit of the number of documents returned from the `list` operation.
     */
    listHardLimit: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['listHardLimit']>;
    /**
     * The object schema to define the access control policy for each model field.
     */
    permissionSchema: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['permissionSchema']>;
    /**
     * The object field to store the document permissions.
     */
    documentPermissionField: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['documentPermissionField']>;
    /**
     * The model fields always selected for ACL and response shaping.
     */
    alwaysSelectFields: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['alwaysSelectFields']>;
    /**
     * The function called in the process of generating document permissions.
     */
    docPermissions: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['docPermissions']>;
    /**
     * The access control policy for router operations.
     * @operation `create`, `list`, `read`, `update`, `delete`
     */
    operationAccess: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['operationAccess']>;
    /**
     * The base filter definitions applied in every query transaction.
     * @operation `list`, `read`, `update`, `delete`
     */
    baseFilter: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['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>, ModelRouterOptions<TModel>['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>, ModelRouterOptions<TModel>['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>, ModelRouterOptions<TModel>['prepare']>;
    /**
     * Hook
     *
     * The function called before an updated document is saved.
     * @operation `update`
     */
    transform: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['transform']>;
    /**
     * Hook
     *
     * The function called after a new document is created or an updated document is saved.
     * @operation `create`, `update`
     */
    afterPersist: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['afterPersist']>;
    /**
     * Hook
     *
     * The function called after an updated document changes have been finalized.
     * @operation `update`
     */
    onChange: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['onChange']>;
    /**
     * Hook
     *
     * The function called before a document is deleted.
     * @operation `delete`
     */
    beforeDelete: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['beforeDelete']>;
    /**
     * Hook
     *
     * The function called after a document is deleted.
     * @operation `delete`
     */
    afterDelete: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['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>, ModelRouterOptions<TModel>['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>, ModelRouterOptions<TModel>['decorateAll']>;
    /**
     * The field matched against the `id` route param.
     * @operation `read`, `update`, `delete`
     */
    idField: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['idField']>;
    /**
     * The function used to resolve the `id` route param into a document filter.
     * @operation `read`, `update`, `delete`
     */
    resolveIdFilter: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['resolveIdFilter']>;
    /**
     * The route segment used for advanced query endpoints.
     */
    queryRouteSegment: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['queryRouteSegment']>;
    /**
     * The route segment used for advanced mutation endpoints.
     */
    mutationRouteSegment: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['mutationRouteSegment']>;
    /**
     * The default values used when missing in the operations.
     */
    defaults: SetTargetOption<ModelRouter<TModel>, ModelRouterOptions<TModel>['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>(modelName: string, options: ModelRouterOptions<TModel>) => void;
declare const setModelOption: <K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K, value: ExtendedModelRouterOptions<TModel>[K]) => void;
declare const getModelOptions: <TModel = unknown>(modelName: string) => ModelRouterOptions<TModel>;
declare const getModelOption: <K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string, defaultValue?: ExtendedModelRouterOptions<TModel>[K]) => ExtendedModelRouterOptions<TModel>[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>(model: mongoose.Model<TModel>, options: ModelRouterOptions<TModel>): ModelRouter<TModel>;
    <TModel>(modelName: string, options: ModelRouterOptions<TModel>): ModelRouter<TModel>;
    (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, ExtendedDefaultModelRouterOptions, ExtendedModelRouterOptions, GlobalOptions, GuardHook, type GuardModelCondition, type GuardModelConditionID, ModelRouter, ModelRouterOptions, type OpLogContext, OpenApiCollisionError, type OpenApiDocumentOptions, type OpenApiMethod, OpenApiRegistry, type OpenApiRegistryOptions, type OpenApiRouteDescriptor, type OpenApiRouterOptions, RootRouter, RootRouterOptions, Validation, acl, combineRoutes, createAccessRuntime, createOpenApiRouter, acl as default, defaultRuntime, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelInstance, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, hasModelInstance, isLevelEnabled, permissionsPlugin, redactFilter, redactPayload, registerModelInstance, safeStringify, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions };