@web-ts-toolkit/access-router 0.29.0 → 0.31.0

package/index.d.mts

@@ -1,9 +1,231 @@
 import mongoose from 'mongoose';
-import { Response, NextFunction, Router } from 'express';
-import { a7 as GlobalOptions, Q as DefaultModelRouterOptions, Y as ExtendedDefaultModelRouterOptions, ax as ModelRouterOptions, Z as ExtendedModelRouterOptions, M as DataRouterOptions, X as ExtendedDataRouterOptions, A as AccessRouterBaseRequest, a9 as GuardHook, aw as ModelRequest, K as DataRequest, cn as DataService, co as Model, cp as Service, cq as PublicService, c0 as Validation, bm as RootRouterOptions } from './parsers-Cj4r_G4g.mjs';
-export { cr as AccessRouterPermissionMap, cs as AccessRouterPermissions, c as AccessRouterRequest, d as AccessRouterRequestExtensions, l as AjvErrorObjectLike, m as AjvValidatorLike, n as ArkTypeErrorsLike, o as ArkTypeLike, ac as IoTsContextEntryLike, ad as IoTsDecodeErrorLike, ae as IoTsDecoderLike, af as JoiSchemaLike, ag as JoiValidationErrorDetailLike, ct as Permissions, aS as RequestSchemaAdapter, aT as RequestSchemaFailure, aU as RequestSchemaIssue, aV as RequestSchemaLike, aW as RequestSchemaOptions, aX as RequestSchemaResult, aY as RequestSchemaSuccess, aZ as RequestSchemaValidator, bx as StandardSchemaFailure, by as StandardSchemaInferOutput, bz as StandardSchemaIssue, bA as StandardSchemaPathSegment, bB as StandardSchemaResult, bC as StandardSchemaSuccess, bD as StandardSchemaV1, bJ as SuperstructFailureLike, bK as SuperstructValidateLike, bW as ValibotIssueLike, bX as ValibotPathItemLike, bY as ValibotSafeParseLike, bZ as ValibotSafeParseResult, c2 as VineValidationErrorLike, c3 as VineValidationMessageLike, c4 as VineValidatorLike, c5 as YupSchemaLike, c6 as YupValidationErrorLike, c7 as defineRequestSchema, c8 as fromAjv, c9 as fromArkType, ca as fromIoTs, cb as fromJoi, cc as fromStandardSchema, cd as fromSuperstruct, ce as fromValibot, cf as fromVine, cg as fromYup, ch as fromZod } from './parsers-Cj4r_G4g.mjs';
+import express, { Router, Response, NextFunction, RequestHandler } from 'express';
 import JsonRouter from '@web-ts-toolkit/express-json-router';
-import 'zod';
+import { z } from 'zod';
+
+interface BooleanObject {
+    [key: string]: boolean;
+}
+interface AccessRouterPermissionMap {
+}
+type AccessRouterPermissionKey = Extract<keyof AccessRouterPermissionMap, string>;
+type PermissionName = AccessRouterPermissionKey | (string & {});
+declare class Permission {
+    private readonly permissions;
+    private readonly permissionKeys;
+    constructor(permissions: BooleanObject);
+    get keys(): readonly string[];
+    private normalizePermissionArgs;
+    hasKey(permission: PermissionName): boolean;
+    has(permission: PermissionName): boolean;
+    hasAny(permissionOrPermissions: PermissionName | readonly PermissionName[], ...permissions: PermissionName[]): boolean;
+    hasAll(permissionOrPermissions: PermissionName | readonly PermissionName[], ...permissions: PermissionName[]): boolean;
+}
+
+type Permissions = Permission;
+type AccessRouterPermissions = Permission;
+
+declare class Base<TModel = unknown> {
+    protected req: ModelRequest;
+    protected modelName: string;
+    constructor(req: ModelRequest, modelName: string);
+    decorate<T>(doc: T, access: DecorateAccess, context: ModelHookContext): Promise<T>;
+    decorateAll<T>(docs: T[], access: DecorateAllAccess, context: ModelHookContext): Promise<T[]>;
+    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    genDocPermissions(doc: unknown, access: DocPermissionsAccess, context: ModelHookContext): Promise<Record<string, unknown>>;
+    genFilter(access?: BaseFilterAccess, filter?: Filter<TModel>): Promise<Filter<TModel>>;
+    getIdentifier(): string | null;
+    genIDFilter(id: string): Promise<Filter<TModel>>;
+    genPopulate(access?: SelectAccess, populate?: Populate | Populate[] | string | null): Promise<Populate[]>;
+    genSelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    genQuerySelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    addEmptyPermissions<T>(doc: T): T;
+    addDocPermissions<T>(doc: T, access: DocPermissionsAccess, context: ModelHookContext): Promise<T>;
+    addFieldPermissions<T extends {
+        _id?: unknown;
+    }>(doc: T, access: DocPermissionsAccess, context: ModelHookContext): Promise<T>;
+    pickAllowedFields<T>(doc: T, access: SelectAccess, baseFields?: string[]): Promise<T>;
+    trimOutputFields<T>(doc: T, access: SelectAccess, baseFields?: string[]): Promise<T>;
+    prepare<T>(allowedData: T, access: PrepareAccess, context: ModelHookContext): Promise<T>;
+    runTasks<T extends object>(docObject: T, tasks: Task | Task[]): T;
+    transform<T>(doc: T, access: TransformAccess, context: ModelHookContext): Promise<T>;
+    afterPersist<T>(doc: T, access: AfterPersistAccess, context: ModelHookContext): Promise<T>;
+    changes(doc: Record<string, unknown>, context: ModelHookContext): Promise<void>;
+    beforeDelete<T>(doc: T, context: ModelHookContext): Promise<void>;
+    afterDelete<T>(doc: T, context: ModelHookContext): Promise<void>;
+    validate(allowedData: unknown, access: ValidateAccess, context: ModelHookContext): Promise<boolean | unknown[]>;
+    checkIfModelPermissionExists(accesses: DocPermissionsAccess[]): boolean;
+    protected validateClientFilter(filter: Filter | null | undefined): string[];
+    protected processInclude(include: Include | Include[]): {
+        includes: Include[];
+        includeLocalFields: string[];
+        includePaths: string[];
+    };
+    protected includeDocs(docs: any, include: Include | Include[]): Promise<any>;
+    private includeDocsList;
+    private includeDocsCount;
+    protected parseClientData<TValue>(filter: TValue): Promise<TValue>;
+    private handleSubQuery;
+    private handleDate;
+}
+
+interface FindProps {
+    filter: Filter;
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    limit?: string | number;
+    skip?: string | number;
+    lean?: boolean;
+}
+interface FindOneProps {
+    filter: Filter;
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    lean?: boolean;
+}
+type SortValue = 1 | -1 | 'asc' | 'ascending' | 'desc' | 'descending';
+type SortType = string | [string, SortValue][] | {
+    [key: string]: SortValue;
+} | Map<string, SortValue> | null | undefined;
+declare class Model {
+    modelName: string;
+    model: mongoose.Model<any>;
+    constructor(modelName: string);
+    new(): any;
+    create(data: any): Promise<any>;
+    find({ filter, select, sort, populate, limit, skip, lean }: FindProps): mongoose.Query<any[], any, {}, any, "find", {}>;
+    validateSort(sort: SortType, logError?: (msg: string, ...args: unknown[]) => void): boolean;
+    findOne({ filter, select, sort, populate, lean }: FindOneProps): mongoose.Query<any, any, {}, any, "findOne", {}>;
+    exists(filter: any): mongoose.Query<any, any, {}, any, "findOne", {}>;
+    countDocuments(filter?: {}): mongoose.Query<number, any, {}, any, "countDocuments", {}>;
+    distinct(field: string, conditions?: {}): mongoose.Query<any[], any, {}, any, "distinct", {}>;
+}
+
+declare class Service<TModel = unknown> extends Base<TModel> {
+    protected model: Model;
+    protected options: ModelRouterOptions<TModel>;
+    defaults: Defaults<TModel>;
+    protected baseFields: string[];
+    protected baseFieldsExt: string[];
+    private asServiceHookContext;
+    constructor(req: ModelRequest, modelName: string);
+    findOne(filter: Filter<TModel>, args?: FindOneArgs<TModel>, options?: FindOneOptions): Promise<SingleResult<TModel> | ErrorResult>;
+    findById(id: string, args?: FindByIdArgs<TModel>, options?: FindByIdOptions): Promise<SingleResult<TModel> | ErrorResult>;
+    find(filter: Filter<TModel>, args?: FindArgs<TModel>, options?: FindOptions, decorate?: Function): Promise<ListResult<TModel> | ErrorResult>;
+    create(data: any, args?: CreateArgs, options?: CreateOptions, decorate?: Function): Promise<ListResult<TModel> | ErrorResult>;
+    new(): Promise<SingleResult<TModel>>;
+    updateOne(filter: Filter<TModel>, data: any, args?: UpdateOneArgs<TModel>, options?: UpdateOneOptions, decorate?: Function): Promise<SingleResult<TModel> | ErrorResult>;
+    updateById(id: string, data: any, args?: UpdateByIdArgs<TModel>, options?: UpdateByIdOptions, decorate?: Function): Promise<SingleResult<TModel> | ErrorResult>;
+    upsert(filter: Filter<TModel>, data: any, args?: UpsertArgs<TModel>, options?: UpsertOptions, decorate?: Function): Promise<ServiceResult<TModel>>;
+    delete(id: string): Promise<SingleResult<unknown> | ErrorResult>;
+    exists(filter: Filter<TModel>, options: ExistsOptions & {
+        includeId: true;
+    }): Promise<SingleResult<unknown> | ErrorResult>;
+    exists(filter: Filter<TModel>, options?: ExistsOptions): Promise<SingleResult<boolean> | ErrorResult>;
+    distinct(field: string, args?: DistinctArgs<TModel>): Promise<ListResult<unknown> | ErrorResult>;
+    count(filter: Filter<TModel>, access?: BaseFilterAccess): Promise<SingleResult<number> | ErrorResult>;
+    getDocPermissions(doc: unknown): Record<string, unknown>;
+    private resolveFindOneArgs;
+    private resolveFindOneOptions;
+    private resolveFindByIdArgs;
+    private resolveFindByIdOptions;
+    private resolveFindArgs;
+    private resolveFindOptions;
+    private resolveCreateArgs;
+    private resolveCreateOptions;
+    private resolveUpdateOneArgs;
+    private resolveUpdateOneOptions;
+    private resolveUpdateByIdArgs;
+    private resolveUpdateByIdOptions;
+    private resolveUpsertArgs;
+    private resolveUpsertOptions;
+    private resolveExistsOptions;
+    private getFieldPermissionAccess;
+    private getAccessibleIdSet;
+    listSub(id: any, sub: any, options?: {
+        filter: Filter;
+        select: string[];
+    }): Promise<ListResult | ErrorResult>;
+    readSub(id: any, sub: any, subId: any, options?: {
+        select: string[];
+        populate: SubPopulate | SubPopulate[];
+    }): Promise<SingleResult | ErrorResult>;
+    updateSub(id: any, sub: any, subId: any, data: any): Promise<SingleResult | ErrorResult>;
+    bulkUpdateSub(id: any, sub: any, data: any): Promise<ListResult | ErrorResult>;
+    createSub(id: any, sub: any, data: any, options?: {
+        addFirst: boolean;
+    }): Promise<ListResult | ErrorResult>;
+    deleteSub(id: any, sub: any, subId: any): Promise<SingleResult | ErrorResult>;
+    getParentDoc(id: any, sub: any, args?: {
+        populate?: SubPopulate | SubPopulate[];
+    }, options?: {
+        access?: BaseFilterAccess;
+        lean?: boolean;
+    }): Promise<any>;
+}
+
+declare class PublicService<TModel = unknown> extends Service<TModel> {
+    _list<TSelect extends Projection | undefined = undefined, TPopulate extends Populate[] | string | undefined = undefined>(filter: Filter<TModel>, args?: Omit<PublicListArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+    }, options?: PublicListOptions): Promise<ListResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _create<TSelect extends Projection | undefined = undefined, TPopulate extends Populate[] | string | undefined = undefined>(data: any, args?: Omit<PublicCreateArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+    }, options?: PublicCreateOptions): Promise<ListResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _new(): Promise<SingleResult<PublicOutput<TModel>>>;
+    _read<TSelect extends Projection | undefined = undefined, TPopulate extends Populate[] | string | undefined = undefined>(id: string, args?: Omit<PublicReadArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+    }, options?: PublicReadOptions): Promise<SingleResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _readFilter<TSelect extends Projection | undefined = undefined, TPopulate extends Populate[] | string | undefined = undefined>(filter: Filter<TModel>, args?: Omit<PublicReadArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+        sort?: Sort;
+    }, options?: PublicReadOptions): Promise<SingleResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _update<TSelect extends Projection | undefined = undefined, TPopulate extends Populate[] | string | undefined = undefined>(id: string, data: any, args?: Omit<PublicUpdateArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+    }, options?: PublicUpdateOptions): Promise<SingleResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _upsert<TSelect extends Projection | undefined = undefined, TPopulate extends Populate[] | string | undefined = undefined>(data: Record<string, unknown>, args?: Omit<PublicUpsertArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+    }, options?: PublicUpsertOptions): Promise<ServiceResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _delete(id: string): Promise<SingleResult<unknown> | ErrorResult>;
+    _distinct(field: string, options?: DistinctArgs<TModel>): Promise<ListResult<unknown> | ErrorResult>;
+    _count(filter: Filter<TModel>, access?: BaseFilterAccess): Promise<SingleResult<number> | ErrorResult>;
+    private resolvePublicListArgs;
+    private resolvePublicListOptions;
+    private resolvePublicCreateArgs;
+    private resolvePublicCreateOptions;
+    private resolvePublicReadArgs;
+    private resolvePublicReadFilterArgs;
+    private resolvePublicReadOptions;
+    private resolvePublicUpdateArgs;
+    private resolvePublicUpdateOptions;
+}
+
+declare class DataService<T> {
+    protected req: DataRequest;
+    protected dataName: string;
+    protected options: DataRouterOptions<T>;
+    protected data: T[];
+    constructor(req: DataRequest, dataName: string);
+    findOne<TSelect extends Projection | undefined = undefined>(filter: DataFilter<T>, args?: DataFindOneArgs<T, TSelect>, options?: DataFindOneOptions): Promise<SingleResult<SelectedPublicOutput<T, TSelect>> | ErrorResult>;
+    findById<TSelect extends Projection | undefined = undefined>(id: string, args?: DataFindOneArgs<T, TSelect>, options?: DataFindOneOptions): Promise<SingleResult<SelectedPublicOutput<T, TSelect>> | ErrorResult>;
+    find<TSelect extends Projection | undefined = undefined>(filter: DataFilter<T>, args?: DataFindArgs<T, TSelect>, options?: DataFindOptions): Promise<ListResult<SelectedPublicOutput<T, TSelect>> | ErrorResult>;
+    decorate<TDoc>(doc: TDoc, access: DecorateAccess, context?: DataHookContext): Promise<TDoc>;
+    decorateAll<TDoc>(docs: TDoc[], access: DecorateAllAccess, context?: DataHookContext): Promise<TDoc[]>;
+    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    genFilter(access?: BaseFilterAccess, filter?: DataFilter<T>): Promise<DataFilter<T>>;
+    genIDFilter(id: string): Promise<DataFilter<T>>;
+    genSelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    genQuerySelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    pickAllowedFields<TDoc>(doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
+    trimOutputFields<TDoc>(doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
+}
 
 type OpenApiMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
 type OpenApiSchema = Record<string, unknown>;
@@ -52,6 +274,8 @@ type OpenApiRouterOptions = Partial<OpenApiDocumentOptions> & {
     swaggerUiBundleUrl?: string;
 };
 
+declare function createOpenApiRouter(runtime: AccessRuntime, options?: OpenApiRouterOptions): Router;
+
 declare class AccessRuntime {
     private readonly globalOptions;
     private readonly defaultModelOptions;
@@ -112,14 +336,911 @@ declare class AccessRuntime {
     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): any;
+    getModelRef(modelName: string, refPath: string): string | null;
     getModelSub(modelName: string): string[];
-    getModelAtt(modelName: string): any[];
+    getModelAtt(modelName: string): string[];
+}
+
+type InternalModelHookContext = ModelHookContext & {
+    fieldPermissionAccess?: {
+        readIds?: Set<string>;
+        updateIds?: Set<string>;
+    };
+};
+declare class Core {
+    private req;
+    private caches;
+    constructor(req: AccessRouterBaseRequest);
+    getIdentifier(modelName: string): string;
+    genIDFilter<TModel = unknown>(modelName: string, id: string): Promise<Filter<TModel>>;
+    genFilter<TModel = unknown>(modelName: string, access?: BaseFilterAccess, _filter?: Filter<TModel>): Promise<Filter<TModel>>;
+    private removePrefix;
+    genAllowedFields(modelName: string, doc: unknown, access: SelectAccess, baseFields?: any[]): Promise<string[]>;
+    pickAllowedFields<T>(modelName: string, doc: T, access: SelectAccess, baseFields?: any[]): Promise<T>;
+    genSelect(modelName: string, access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: any[]): Promise<string[]>;
+    genPopulate(modelName: string, access?: SelectAccess | BaseFilterAccess, _populate?: Populate | Populate[] | string | null): Promise<(string | Populate)[]>;
+    validate(modelName: string, allowedData: unknown, access: ValidateAccess, context: ModelHookContext): Promise<boolean | unknown[]>;
+    prepare<T>(modelName: string, allowedData: T, access: PrepareAccess, context: ModelHookContext): Promise<T>;
+    transform<T>(modelName: string, doc: T, access: TransformAccess, context: ModelHookContext): Promise<T>;
+    afterPersist<T>(modelName: string, doc: T, access: AfterPersistAccess, context: ModelHookContext): Promise<T>;
+    changes(modelName: string, doc: Record<string, unknown>, context: ModelHookContext): Promise<void>;
+    beforeDelete<T>(modelName: string, doc: T, context: ModelHookContext): Promise<void>;
+    afterDelete<T>(modelName: string, doc: T, context: ModelHookContext): Promise<void>;
+    genDocPermissions(modelName: string, doc: unknown, access: DocPermissionsAccess, context: ModelHookContext): Promise<{}>;
+    addEmptyPermissions<T>(modelName: string, doc: T): T;
+    addDocPermissions<T>(modelName: string, doc: T, access: DocPermissionsAccess, context: ModelHookContext): Promise<T>;
+    addFieldPermissions<T extends {
+        _id?: unknown;
+    }>(modelName: string, doc: T, access: DocPermissionsAccess, context: InternalModelHookContext): Promise<T>;
+    decorate<T>(modelName: string, doc: T, access: DecorateAccess, context: ModelHookContext): Promise<T>;
+    decorateAll<T>(modelName: string, docs: T[], access: DecorateAllAccess, context: ModelHookContext): Promise<T[]>;
+    runTasks<T extends object>(modelName: string, docObject: T, task: Task | Task[]): T;
+    getPermissions(): Permission;
+    setPermissions(): Promise<void>;
+    canActivate(routeGuard: Validation): Promise<boolean>;
+    isAllowed(modelName: string, access: RouteGuardAccess | string): Promise<boolean>;
+    getService<TModel = unknown>(modelName: string): Service<TModel>;
+    getPublicService<TModel = unknown>(modelName: string): PublicService<TModel>;
+    service<TModel = unknown>(modelName: string): PublicService<TModel>;
+    svc<TModel = unknown>(modelName: string): PublicService<TModel>;
+    private getGlobalPermissions;
+}
+
+declare class DataCore {
+    private req;
+    private caches;
+    constructor(req: AccessRouterBaseRequest);
+    genIDFilter<TData = unknown>(dataName: string, id: string): Promise<Filter<TData>>;
+    genFilter<TData = unknown>(dataName: string, access?: BaseFilterAccess, _filter?: Filter<TData>): Promise<Filter<TData>>;
+    genAllowedFields(dataName: string, _doc: unknown, access: SelectAccess, baseFields?: any[]): Promise<string[]>;
+    pickAllowedFields<TDoc>(dataName: string, doc: TDoc, access: SelectAccess, baseFields?: any[]): Promise<TDoc>;
+    genSelect(dataName: string, access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: any[]): Promise<string[]>;
+    decorate<TDoc>(dataName: string, doc: TDoc, access: DecorateAccess, context?: DataHookContext): Promise<TDoc>;
+    decorateAll<TDoc>(dataName: string, docs: TDoc[], access: DecorateAllAccess, context?: DataHookContext): Promise<TDoc[]>;
+    getPermissions(): Permission;
+    setPermissions(): Promise<void>;
+    canActivate(routeGuard: Validation): Promise<boolean>;
+    isAllowed(dataName: string, access: RouteGuardAccess | string): Promise<boolean>;
+    getService<TData = unknown>(dataName: string): DataService<TData>;
+    service<TData = unknown>(dataName: string): DataService<TData>;
+    svc<TData = unknown>(dataName: string): DataService<TData>;
+    private getGlobalPermissions;
+}
+
+declare enum Codes {
+    Success = "success",
+    Created = "created",
+    BadRequest = "bad_request",
+    Unauthorized = "unauthorized",
+    Forbidden = "forbidden",
+    NotFound = "not_found"
+}
+
+interface AccessRouterRequestExtensions {
+    macl?: Core;
+    dacl?: DataCore;
+}
+type AccessRouterRequest = express.Request & AccessRouterRequestExtensions;
+
+type GuardHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, permissions: AccessRouterPermissions) => boolean | Promise<boolean>;
+type Validation = boolean | string | string[] | GuardHook;
+type SelectAccess = 'list' | 'create' | 'read' | 'update' | string;
+type RouteGuardAccess = 'new' | 'list' | 'read' | 'update' | 'upsert' | 'delete' | 'create' | 'distinct' | 'count' | 'subs' | string;
+type DocPermissionsAccess = 'list' | 'create' | 'read' | 'update' | string;
+type BaseFilterAccess = 'list' | 'read' | 'update' | 'delete' | string;
+type DecorateAccess = 'list' | 'create' | 'read' | 'update' | string;
+type DecorateAllAccess = 'list' | string;
+type ValidateAccess = 'create' | 'update' | string;
+type PrepareAccess = 'create' | 'update' | string;
+type TransformAccess = 'update' | string;
+type AfterPersistAccess = 'create' | 'update' | string;
+
+interface PublicCreateArgs {
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+}
+interface CreateArgs extends Omit<PublicCreateArgs, 'select' | 'tasks'> {
+}
+interface PublicCreateOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    populateAccess?: PopulateAccess;
+}
+interface CreateOptions extends PublicCreateOptions {
+}
+
+interface PublicListArgs {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    sort?: Sort;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+    tasks?: Task | Task[];
+}
+interface PublicListOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    populateAccess?: PopulateAccess;
+    lean?: boolean;
+}
+
+interface PublicReadArgs {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+}
+interface PublicReadOptions {
+    skim?: boolean;
+    populateAccess?: PopulateAccess;
+    lean?: boolean;
+    includePermissions?: boolean;
+    tryList?: boolean;
+}
+
+interface PublicUpdateArgs {
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+}
+interface PublicUpsertArgs extends PublicUpdateArgs {
+}
+interface UpdateOneArgs<T = unknown> extends Omit<PublicUpdateArgs, 'select' | 'tasks'> {
+    overrides?: {
+        filter?: Filter<T>;
+        populate?: Populate[] | string;
+    };
+}
+interface UpdateByIdArgs<T = unknown> extends Omit<UpdateOneArgs<T>, 'overrides'> {
+    overrides?: {
+        populate?: Populate[] | string;
+        idFilter?: Filter<T>;
+    };
+}
+interface UpsertArgs<T = unknown> extends UpdateOneArgs<T> {
+}
+interface PublicUpdateOptions {
+    skim?: boolean;
+    returningAll?: boolean;
+    includePermissions?: boolean;
+    populateAccess?: PopulateAccess;
+}
+interface PublicUpsertOptions extends PublicUpdateOptions {
+}
+interface UpdateOneOptions extends Omit<PublicUpdateOptions, 'returningAll'> {
+}
+interface UpdateByIdOptions extends UpdateOneOptions {
+}
+interface UpsertOptions extends UpdateOneOptions {
+}
+
+type DataFilter<T = unknown> = Filter<T>;
+interface DataFindOneArgs<T = unknown, TSelect extends Projection | undefined = Projection | undefined> {
+    select?: TSelect;
+}
+interface DataFindOneOptions {
+    access?: FindAccess;
+}
+interface DataFindArgs<T = unknown, TSelect extends Projection | undefined = Projection | undefined> {
+    select?: TSelect;
+    sort?: string;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+}
+interface DataFindOptions {
+}
+
+interface KeyValueProjection {
+    [key: string]: 1 | -1;
+}
+type Projection = string[] | string | KeyValueProjection;
+type SortOrder = -1 | 1 | 'asc' | 'ascending' | 'desc' | 'descending';
+type Sort = string | {
+    [key: string]: SortOrder;
+} | [string, SortOrder][] | undefined | null;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type NonTraversable = Primitive | Date | RegExp | Function;
+type PrevDepth = [never, 0, 1, 2, 3, 4, 5];
+type IsUnknown<T> = unknown extends T ? ([keyof T] extends [never] ? true : false) : false;
+type Descend<T> = T extends readonly (infer U)[] ? U : T;
+type ArrayValue<T> = T extends readonly (infer U)[] ? U : T;
+type ComparableValue = string | number | bigint | Date;
+type WithDefaultId<T> = T extends object ? T & {
+    _id?: unknown;
+} : {
+    _id?: unknown;
+};
+type PublicOutput<T> = T extends object ? T & Record<string, unknown> : Record<string, unknown>;
+type ModelDocument<TModel = unknown> = mongoose.Document & TModel;
+type TrimLeft<S extends string> = S extends ` ${infer Rest}` ? TrimLeft<Rest> : S;
+type TrimRight<S extends string> = S extends `${infer Rest} ` ? TrimRight<Rest> : S;
+type Trim<S extends string> = TrimLeft<TrimRight<S>>;
+type SplitProjectionString<S extends string> = S extends `${infer Head} ${infer Tail}` ? SplitProjectionString<Head> | SplitProjectionString<Tail> : Trim<S>;
+type ProjectionTokens<TProjection> = TProjection extends readonly string[] ? TProjection[number] : TProjection extends string ? SplitProjectionString<TProjection> : TProjection extends KeyValueProjection ? {
+    [K in Extract<keyof TProjection, string>]: TProjection[K] extends 1 ? K : never;
+}[Extract<keyof TProjection, string>] : never;
+type PositiveProjectionPaths<TProjection> = ProjectionTokens<TProjection> extends infer TToken ? TToken extends string ? TToken extends '' ? never : TToken extends `-${string}` ? never : TToken : never : never;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer I) => void ? I : never;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type DeepPickSingle<T, TPath extends string> = TPath extends `${infer Head}.${infer Tail}` ? Head extends keyof WithDefaultId<T> ? Head extends string ? {
+    [K in Head]: WithDefaultId<T>[K] extends readonly (infer U)[] ? Array<Simplify<DeepPickSingle<U, Tail>>> : WithDefaultId<T>[K] extends object ? Simplify<DeepPickSingle<WithDefaultId<T>[K], Tail>> : WithDefaultId<T>[K];
+} : {} : {} : TPath extends keyof WithDefaultId<T> ? Pick<WithDefaultId<T>, TPath> : {};
+type DeepPick<T, TPaths extends string> = Simplify<UnionToIntersection<DeepPickSingle<T, TPaths>>>;
+type SelectedPublicOutput<T, TProjection> = string extends PositiveProjectionPaths<TProjection> ? PublicOutput<T> : [PositiveProjectionPaths<TProjection>] extends [never] ? PublicOutput<T> : DeepPick<T, Extract<PositiveProjectionPaths<TProjection>, string>>;
+type PopulateInput = Populate | string;
+type PopulateInputs<TPopulate> = TPopulate extends readonly (infer U)[] ? U : TPopulate;
+type PopulatePath<TPopulateEntry> = TPopulateEntry extends string ? TPopulateEntry : TPopulateEntry extends {
+    path: infer TPath extends string;
+} ? TPath : never;
+type PopulateSelect<TPopulateEntry> = TPopulateEntry extends {
+    select?: infer TSelect;
+} ? TSelect : undefined;
+type PopulateLeafValue<TValue, TPopulateEntry> = TValue extends readonly (infer U)[] ? Array<SelectedPublicOutput<U, PopulateSelect<TPopulateEntry>>> : SelectedPublicOutput<TValue, PopulateSelect<TPopulateEntry>>;
+type PopulateEntryShape<T, TPath extends string, TValue> = TPath extends `${infer Head}.${infer Tail}` ? Head extends keyof WithDefaultId<T> ? Head extends string ? {
+    [K in Head]: WithDefaultId<T>[K] extends readonly (infer U)[] ? Array<Simplify<PopulateEntryShape<U, Tail, TValue>>> : Simplify<PopulateEntryShape<WithDefaultId<T>[K], Tail, TValue>>;
+} : {} : {} : TPath extends keyof WithDefaultId<T> ? Pick<{
+    [K in TPath]: TValue;
+}, TPath> : {};
+type PopulateOutputShape<T, TPopulateEntry> = PopulatePath<TPopulateEntry> extends infer TPath extends string ? PopulateEntryShape<T, TPath, PopulateLeafValue<PathValue<WithDefaultId<T>, TPath>, TPopulateEntry>> : {};
+type PopulateOutput<T, TPopulate> = string extends PopulatePath<PopulateInputs<TPopulate>> ? {} : [PopulatePath<PopulateInputs<TPopulate>>] extends [never] ? {} : Simplify<UnionToIntersection<PopulateOutputShape<T, Extract<PopulateInputs<TPopulate>, PopulateInput>>>>;
+type SelectedPopulatedPublicOutput<T, TProjection, TPopulate> = Simplify<SelectedPublicOutput<T, TProjection> & PopulateOutput<T, TPopulate>>;
+type DeepFieldPath<T, Depth extends number = 4> = [Depth] extends [never] ? never : Descend<T> extends NonTraversable ? never : {
+    [K in Extract<keyof Descend<T>, string>]: K | (Descend<T>[K] extends NonTraversable ? never : Descend<T>[K] extends readonly (infer U)[] ? U extends NonTraversable ? never : `${K}.${DeepFieldPath<U, PrevDepth[Depth]>}` : Descend<T>[K] extends object ? `${K}.${DeepFieldPath<Descend<T>[K], PrevDepth[Depth]>}` : never);
+}[Extract<keyof Descend<T>, string>];
+type PathValue<T, TPath extends string> = TPath extends `${infer Head}.${infer Tail}` ? Head extends Extract<keyof Descend<T>, string> ? PathValue<Descend<Descend<T>[Head]>, Tail> : unknown : TPath extends Extract<keyof Descend<T>, string> ? Descend<T>[TPath] : unknown;
+type FieldFilterOperators<T> = {
+    $eq?: T;
+    $ne?: T;
+    $in?: Array<ArrayValue<T>>;
+    $nin?: Array<ArrayValue<T>>;
+    $exists?: boolean;
+    $gt?: ArrayValue<T> extends ComparableValue ? ArrayValue<T> : never;
+    $gte?: ArrayValue<T> extends ComparableValue ? ArrayValue<T> : never;
+    $lt?: ArrayValue<T> extends ComparableValue ? ArrayValue<T> : never;
+    $lte?: ArrayValue<T> extends ComparableValue ? ArrayValue<T> : never;
+    $regex?: ArrayValue<T> extends string ? string | RegExp : never;
+    $all?: T extends readonly unknown[] ? Array<ArrayValue<T>> : never;
+    $size?: T extends readonly unknown[] ? number : never;
+    $elemMatch?: ArrayValue<T> extends object ? TypedFilter<ArrayValue<T>> : never;
+    $$sq?: unknown;
+    $$date?: unknown;
+    [key: `$${string}`]: unknown;
+};
+type FieldFilterValue<T> = T | FieldFilterOperators<NonNullable<T>>;
+type LooseFilter = false | Record<string, unknown>;
+type TypedFilterObject<T> = {
+    [K in DeepFieldPath<T>]?: FieldFilterValue<PathValue<T, K>>;
+} & {
+    _id?: FieldFilterValue<unknown>;
+    $and?: TypedFilter<T>[];
+    $or?: TypedFilter<T>[];
+    $nor?: TypedFilter<T>[];
+    [key: `$${string}`]: unknown;
+};
+type TypedFilter<T> = false | TypedFilterObject<WithDefaultId<T>>;
+type Filter<T = unknown> = IsUnknown<T> extends true ? LooseFilter : TypedFilter<T>;
+interface Include {
+    model: string;
+    op: 'list' | 'read' | 'count';
+    path: string;
+    filter?: Filter;
+    localField: string;
+    foreignField: string;
+    args?: unknown;
+    options?: unknown;
+}
+type FindAccess = 'list' | 'read';
+type PopulateAccess = 'list' | 'read';
+interface Populate {
+    path: string;
+    select?: Projection;
+    match?: unknown;
+    access?: PopulateAccess;
+}
+interface SubPopulate {
+    path: string;
+    select?: Projection;
+}
+
+interface KeyValue {
+    [key: string]: unknown;
+}
+interface Change {
+    op: 'add' | 'replace' | 'remove';
+    path: Array<string | number>;
+    value?: unknown;
+}
+interface ModelHookContext {
+    modelName: string;
+    mongooseModel: mongoose.Model<unknown>;
+    operation?: string;
+    originalDocumentSnapshot?: Record<string, unknown>;
+    finalDocumentSnapshot?: Record<string, unknown>;
+    currentDocument?: ModelDocument;
+    originalData?: Record<string, unknown>;
+    allowedData?: Record<string, unknown>;
+    preparedData?: Record<string, unknown>;
+    allowedFields?: string[];
+    modifiedPaths?: string[];
+    changes?: Change[];
+    docPermissions?: KeyValue;
+    resolvedQuery?: {
+        filter?: Filter;
+        select?: string[];
+        populate?: Populate[] | string;
+        sort?: Sort;
+        skip?: number;
+        limit?: number;
+    };
+}
+interface DataHookContext {
+    dataName?: string;
+    operation?: string;
+    resolvedQuery?: {
+        filter?: Filter;
+        select?: string[];
+        sort?: Sort;
+        skip?: number;
+        limit?: number;
+    };
+}
+interface Task {
+    type: string;
+    args: unknown;
+    options: Record<string, unknown>;
+}
+interface AccessRouterBaseRequest extends AccessRouterRequest {
+    query: Record<'skip' | 'limit' | 'page' | 'page_size' | 'try_list' | 'skim' | 'include_permissions' | 'include_count' | 'include_extra_headers' | 'returning_all', string>;
+}
+interface ModelRequest extends AccessRouterBaseRequest {
+    macl: Core;
+}
+interface DataRequest extends AccessRouterBaseRequest {
+    dacl: DataCore;
+}
+interface ErrorResult<TError = unknown, TQuery = unknown> {
+    success: false;
+    code: Codes.BadRequest | Codes.Unauthorized | Codes.Forbidden | Codes.NotFound;
+    errors?: TError[];
+    query?: TQuery;
+}
+interface SingleResult<T = unknown, TInput = unknown, TQuery = unknown> {
+    success: true;
+    kind: 'single';
+    code: Codes.Success | Codes.Created;
+    data: T;
+    input?: TInput;
+    query?: TQuery;
+    context?: ModelHookContext;
+}
+interface ListResult<T = unknown, TInput = unknown, TQuery = unknown> {
+    success: true;
+    kind: 'list';
+    code: Codes.Success | Codes.Created;
+    data: T[];
+    count: number;
+    totalCount?: number | null;
+    input?: TInput;
+    query?: TQuery;
+    contexts?: ModelHookContext[];
+}
+type ServiceResult<T = unknown, TError = unknown, TInput = unknown, TQuery = unknown> = SingleResult<T, TInput, TQuery> | ListResult<T, TInput, TQuery> | ErrorResult<TError, TQuery>;
+
+interface FindArgs<T = unknown> {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    sort?: Sort;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+    overrides?: {
+        filter?: Filter<T>;
+        select?: Projection;
+        populate?: Populate[] | string;
+    };
+}
+interface FindOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    populateAccess?: PopulateAccess;
+    lean?: boolean;
+}
+interface FindOneArgs<T = unknown> {
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    overrides?: {
+        filter?: Filter<T>;
+        select?: Projection;
+        populate?: Populate[] | string;
+    };
+}
+interface FindOneOptions {
+    access?: FindAccess;
+    populateAccess?: PopulateAccess;
+    skim?: boolean;
+    lean?: boolean;
+    includePermissions?: boolean;
+}
+interface FindByIdArgs<T = unknown> {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    overrides?: {
+        select?: Projection;
+        populate?: Populate[] | string;
+        idFilter?: Filter<T>;
+    };
+}
+interface FindByIdOptions extends FindOneOptions {
+}
+
+interface ExistsOptions {
+    access?: BaseFilterAccess;
+    includeId?: boolean;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+type AccessRouterFieldKey<T> = [Extract<keyof T, string>] extends [never] ? string : Extract<keyof T, string>;
+type IdentifierHook<TValue, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, id: string) => MaybePromise<Filter<TValue>>;
+type GlobalPermissionValue = Record<string, boolean> | string[] | string | null | undefined;
+type BaseFilterHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, permissions: AccessRouterPermissions) => MaybePromise<Filter | true | null | undefined>;
+type OverrideFilterHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, filter: Filter, permissions: AccessRouterPermissions) => MaybePromise<Filter>;
+type Hook<TValue, TContext, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, value: TValue, permissions: AccessRouterPermissions, context: TContext) => MaybePromise<TValue>;
+type HookChain<TValue, TContext, TRequest extends AccessRouterRequest = AccessRouterRequest> = Hook<TValue, TContext, TRequest> | Array<Hook<TValue, TContext, TRequest>>;
+type ValidateRule = boolean | unknown[];
+type ValidateHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, allowedData: unknown, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<ValidateRule>;
+type DocPermissionsHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, doc: unknown, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<Record<string, unknown>>;
+type ChangeHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, previousValue: unknown, nextValue: unknown, changes: Change[], context: ModelHookContext) => MaybePromise<void>;
+type DeleteHook<TValue = unknown, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, value: TValue, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<void>;
+type DocumentHook<TValue, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, value: ModelDocument<TValue>, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<ModelDocument<TValue>>;
+type DocumentHookChain<TValue, TRequest extends AccessRouterRequest = AccessRouterRequest> = DocumentHook<TValue, TRequest> | Array<DocumentHook<TValue, TRequest>>;
+type ModelBaseFilterHook = BaseFilterHook<ModelRequest>;
+type DataBaseFilterHook = BaseFilterHook<DataRequest>;
+type ModelOverrideFilterHook = OverrideFilterHook<ModelRequest>;
+type DataOverrideFilterHook = OverrideFilterHook<DataRequest>;
+type ModelIdentifierHook<TValue = unknown> = IdentifierHook<TValue, ModelRequest>;
+type DataIdentifierHook<TValue = unknown> = IdentifierHook<TValue, DataRequest>;
+type ModelValidateHook = ValidateHook<ModelRequest>;
+type ModelDocPermissionsHook = DocPermissionsHook<ModelRequest>;
+type ModelChangeHook = ChangeHook<ModelRequest>;
+type ModelDocumentHook<TValue = unknown> = DocumentHookChain<TValue, ModelRequest>;
+type ModelDeleteHook<TValue = unknown> = DeleteHook<ModelDocument<TValue>, ModelRequest>;
+type ModelHook<TValue = unknown> = HookChain<TValue, ModelHookContext, ModelRequest>;
+type ModelListHook<TValue = unknown> = HookChain<TValue[], ModelHookContext, ModelRequest>;
+type DataHook<TValue = unknown> = HookChain<TValue, DataHookContext, DataRequest>;
+type DataListHook<TValue = unknown> = HookChain<TValue[], DataHookContext, DataRequest>;
+
+type RequestSchemaIssue = {
+    message: string;
+    path?: Array<string | number>;
+};
+type RequestSchemaSuccess<T = unknown> = {
+    success: true;
+    data: T;
+};
+type RequestSchemaFailure = {
+    success: false;
+    issues: RequestSchemaIssue[];
+};
+type RequestSchemaResult<T = unknown> = RequestSchemaSuccess<T> | RequestSchemaFailure;
+type RequestSchemaValidator<T = unknown> = (value: unknown) => RequestSchemaResult<T> | Promise<RequestSchemaResult<T>>;
+type RequestSchemaAdapter<T = unknown> = {
+    validate: RequestSchemaValidator<T>;
+    openapi?: Record<string, unknown>;
+};
+type RequestSchemaOptions = {
+    openapi?: Record<string, unknown>;
+};
+type StandardSchemaPathSegment = {
+    key: PropertyKey;
+};
+type StandardSchemaIssue = {
+    message: string;
+    path?: ReadonlyArray<PropertyKey | StandardSchemaPathSegment>;
+};
+type StandardSchemaSuccess<T = unknown> = {
+    value: T;
+    issues?: undefined;
+};
+type StandardSchemaFailure = {
+    issues: ReadonlyArray<StandardSchemaIssue>;
+};
+type StandardSchemaResult<T = unknown> = StandardSchemaSuccess<T> | StandardSchemaFailure;
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown, options?: {
+            readonly libraryOptions?: Record<string, unknown> | undefined;
+        }) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+    };
+};
+type StandardSchemaInferOutput<TSchema extends StandardSchemaV1> = NonNullable<TSchema['~standard']['types']>['output'];
+type RequestSchemaLike<T = unknown> = RequestSchemaValidator<T> | RequestSchemaAdapter<T> | StandardSchemaV1;
+type YupValidationErrorLike = {
+    message: string;
+    path?: string;
+    inner?: ReadonlyArray<YupValidationErrorLike>;
+};
+type YupSchemaLike<T = unknown> = {
+    validate: (value: unknown, options?: {
+        abortEarly?: boolean;
+        stripUnknown?: boolean;
+    }) => Promise<T> | T;
+};
+type JoiValidationErrorDetailLike = {
+    message: string;
+    path?: ReadonlyArray<string | number>;
+};
+type JoiSchemaLike<T = unknown> = {
+    validate: (value: unknown, options?: {
+        abortEarly?: boolean;
+        stripUnknown?: boolean;
+    }) => {
+        value: T;
+        error?: {
+            details?: ReadonlyArray<JoiValidationErrorDetailLike>;
+        };
+    } | Promise<{
+        value: T;
+        error?: {
+            details?: ReadonlyArray<JoiValidationErrorDetailLike>;
+        };
+    }>;
+};
+type AjvErrorObjectLike = {
+    message?: string;
+    instancePath?: string;
+    schemaPath?: string;
+    params?: {
+        missingProperty?: string;
+    };
+};
+type AjvValidatorLike<T = unknown> = {
+    (value: unknown): boolean | Promise<boolean>;
+    errors?: ReadonlyArray<AjvErrorObjectLike> | null;
+};
+type ValibotPathItemLike = {
+    key?: unknown;
+};
+type ValibotIssueLike = {
+    message: string;
+    path?: ReadonlyArray<ValibotPathItemLike>;
+};
+type ValibotSafeParseResult<T = unknown> = {
+    success: true;
+    output: T;
+    issues?: undefined;
+} | {
+    success: false;
+    output?: undefined;
+    issues: ReadonlyArray<ValibotIssueLike>;
+};
+type ValibotSafeParseLike = <TSchema, TOutput = unknown>(schema: TSchema, value: unknown, config?: {
+    abortEarly?: boolean;
+}) => ValibotSafeParseResult<TOutput> | Promise<ValibotSafeParseResult<TOutput>>;
+type ArkTypeProblemLike = {
+    path?: ReadonlyArray<string | number>;
+    message?: string;
+    problem?: string;
+};
+type ArkTypeErrorsLike = ReadonlyArray<ArkTypeProblemLike> & {
+    summary?: string;
+};
+type ArkTypeLike<T = unknown> = {
+    (value: unknown): T | ArkTypeErrorsLike;
+    errors?: unknown;
+};
+type IoTsContextEntryLike = {
+    key: string;
+};
+type IoTsDecodeErrorLike = {
+    message?: string;
+    context: ReadonlyArray<IoTsContextEntryLike>;
+};
+type IoTsDecoderLike<T = unknown> = {
+    decode: (value: unknown) => {
+        _tag: 'Left';
+        left: ReadonlyArray<IoTsDecodeErrorLike>;
+    } | {
+        _tag: 'Right';
+        right: T;
+    };
+};
+type SuperstructFailureLike = {
+    message?: string;
+    path?: ReadonlyArray<string | number>;
+    key?: string | number;
+    branch?: ReadonlyArray<unknown>;
+    failures?: () => ReadonlyArray<SuperstructFailureLike>;
+};
+type SuperstructValidateLike = <TStruct, TOutput = unknown>(value: unknown, struct: TStruct) => readonly [failure: SuperstructFailureLike, value: undefined] | readonly [failure: undefined, value: TOutput] | Promise<readonly [failure: SuperstructFailureLike, value: undefined] | readonly [failure: undefined, value: TOutput]>;
+type VineValidationMessageLike = {
+    field: string;
+    message: string;
+    index?: number;
+};
+type VineValidationErrorLike = {
+    messages: ReadonlyArray<VineValidationMessageLike>;
+};
+type VineValidatorLike<T = unknown> = {
+    validate: (value: unknown) => Promise<T> | T;
+};
+
+interface DefaultFindOneArgs<TModel = unknown> extends Omit<FindOneArgs<TModel>, 'overrides'> {
+}
+interface DefaultFindByIdArgs<TModel = unknown> extends Omit<FindByIdArgs<TModel>, 'overrides'> {
+}
+interface DefaultFindArgs<TModel = unknown> extends Omit<FindArgs<TModel>, 'overrides'> {
+}
+type RequestSchema = RequestSchemaLike;
+type NestedRequestSchema = {
+    default?: RequestSchema;
+    data?: RequestSchema;
+};
+type SubRouteGuardOptions = Record<string, Validation | Record<string, Validation>>;
+interface RequestSchemas {
+    create?: RequestSchema;
+    update?: RequestSchema;
+    upsert?: RequestSchema;
+    count?: RequestSchema;
+    distinct?: RequestSchema;
+    advancedList?: RequestSchema;
+    advancedReadFilter?: RequestSchema;
+    advancedRead?: RequestSchema;
+    advancedCreate?: RequestSchema | NestedRequestSchema;
+    advancedCreateData?: RequestSchema;
+    advancedUpdate?: RequestSchema | NestedRequestSchema;
+    advancedUpdateData?: RequestSchema;
+    advancedUpsert?: RequestSchema | NestedRequestSchema;
+    advancedUpsertData?: RequestSchema;
+    subList?: RequestSchema;
+    subRead?: RequestSchema;
+    subCreate?: RequestSchema;
+    subUpdate?: RequestSchema;
+    subBulkUpdate?: RequestSchema;
+}
+interface DataRequestSchemas {
+    advancedList?: RequestSchema;
+    advancedReadFilter?: RequestSchema;
+    advancedRead?: RequestSchema;
+}
+interface Defaults<TModel = unknown> {
+    findOneArgs?: DefaultFindOneArgs<TModel>;
+    findOneOptions?: FindOneOptions;
+    findByIdArgs?: DefaultFindByIdArgs<TModel>;
+    findByIdOptions?: FindByIdOptions;
+    findArgs?: DefaultFindArgs<TModel>;
+    findOptions?: FindOptions;
+    createArgs?: CreateArgs;
+    createOptions?: CreateOptions;
+    updateOneArgs?: UpdateOneArgs<TModel>;
+    updateOneOptions?: UpdateOneOptions;
+    upsertOptions?: UpsertOptions;
+    updateByIdArgs?: UpdateByIdArgs<TModel>;
+    upsertArgs?: UpsertArgs<TModel>;
+    updateByIdOptions?: UpdateByIdOptions;
+    existsOptions?: ExistsOptions;
+    publicListArgs?: PublicListArgs;
+    publicListOptions?: PublicListOptions;
+    publicCreateArgs?: PublicCreateArgs;
+    publicCreateOptions?: PublicCreateOptions;
+    publicReadArgs?: PublicReadArgs;
+    publicReadOptions?: PublicReadOptions;
+    publicUpdateArgs?: PublicUpdateArgs;
+    publicUpdateOptions?: PublicUpdateOptions;
+}
+interface AccessRouterLogger {
+    debug?: (...args: unknown[]) => unknown;
+    info?: (...args: unknown[]) => unknown;
+    warn?: (...args: unknown[]) => unknown;
+    error?: (...args: unknown[]) => unknown;
+}
+interface GlobalOptions {
+    requestPermissionField?: string;
+    globalPermissions?: (this: AccessRouterRequest, req: AccessRouterRequest) => MaybePromise<GlobalPermissionValue>;
+    logger?: AccessRouterLogger;
+}
+interface RootRouterOptions {
+    basePath: string;
+    operationAccess?: Validation;
+}
+interface OperationAccess {
+    new?: Validation;
+    list?: Validation;
+    create?: Validation;
+    read?: Validation;
+    update?: Validation;
+    upsert?: Validation;
+    delete?: Validation;
+    distinct?: Validation;
+    count?: Validation;
+    subs?: Validation | SubRouteGuardOptions;
+}
+type PermissionRule = Validation | OperationAccess;
+type PermissionSchema<TField extends string = string> = Partial<Record<TField, PermissionRule>>;
+interface DocPermissions {
+    list?: ModelDocPermissionsHook;
+    create?: ModelDocPermissionsHook;
+    read?: ModelDocPermissionsHook;
+    update?: ModelDocPermissionsHook;
+}
+interface DefaultModelRouterOptions<TModel = unknown> {
+    listHardLimit?: number;
+    documentPermissionField?: string;
+    idParam?: string;
+    idField?: string;
+    resolveIdFilter?: ModelIdentifierHook<TModel>;
+    parentPath?: string;
+    queryRouteSegment?: string;
+    mutationRouteSegment?: string;
+    operationAccess?: Validation | OperationAccess;
+    modelPermissionPrefix?: string;
+}
+interface ExtendedDefaultModelRouterOptions<TModel = unknown> extends DefaultModelRouterOptions<TModel> {
+    'operationAccess.default'?: Validation;
+    'operationAccess.new'?: Validation;
+    'operationAccess.list'?: Validation;
+    'operationAccess.read'?: Validation;
+    'operationAccess.update'?: Validation;
+    'operationAccess.delete'?: Validation;
+    'operationAccess.create'?: Validation;
+    'operationAccess.distinct'?: Validation;
+    'operationAccess.count'?: Validation;
+    'operationAccess.subs'?: SubRouteGuardOptions;
+}
+interface ModelRouterOptions<TModel = unknown> extends DefaultModelRouterOptions<TModel> {
+    modelName?: string;
+    basePath?: string;
+    permissionSchema?: PermissionSchema<AccessRouterFieldKey<TModel>>;
+    alwaysSelectFields?: string[];
+    docPermissions?: DocPermissions | ModelDocPermissionsHook;
+    baseFilter?: ModelBaseFilterHook | Record<string, ModelBaseFilterHook>;
+    overrideFilter?: ModelOverrideFilterHook | Record<string, ModelOverrideFilterHook>;
+    decorate?: ModelHook<TModel> | Record<string, ModelHook<TModel>>;
+    decorateAll?: ModelListHook<TModel> | Record<string, ModelListHook<TModel>>;
+    validate?: ValidateRule | ModelValidateHook | Record<string, ValidateRule | ModelValidateHook>;
+    prepare?: ModelHook<TModel> | Record<string, ModelHook<TModel>>;
+    transform?: ModelDocumentHook<TModel> | Record<string, ModelDocumentHook<TModel>>;
+    afterPersist?: ModelDocumentHook<TModel> | Record<string, ModelDocumentHook<TModel>>;
+    onChange?: Record<string, ModelChangeHook>;
+    beforeDelete?: ModelDeleteHook<TModel>;
+    afterDelete?: ModelDeleteHook<TModel>;
+    requestSchemas?: RequestSchemas;
+    defaults?: Defaults<TModel>;
+}
+interface DataRouterOptions<TData = unknown> {
+    data?: TData[];
+    listHardLimit?: number;
+    idParam?: string;
+    idField?: string;
+    resolveIdFilter?: DataIdentifierHook<TData>;
+    parentPath?: string;
+    queryRouteSegment?: string;
+    operationAccess?: Validation | OperationAccess;
+    dataName?: string;
+    basePath?: string;
+    permissionSchema?: PermissionSchema<AccessRouterFieldKey<TData>>;
+    baseFilter?: DataBaseFilterHook | Record<string, DataBaseFilterHook>;
+    overrideFilter?: DataOverrideFilterHook | Record<string, DataOverrideFilterHook>;
+    decorate?: DataHook<TData> | Record<string, DataHook<TData>>;
+    decorateAll?: DataListHook<TData> | Record<string, DataListHook<TData>>;
+    requestSchemas?: DataRequestSchemas;
+}
+interface ExtendedModelRouterOptions<TModel = unknown> extends ModelRouterOptions<TModel>, ExtendedDefaultModelRouterOptions<TModel> {
+    'alwaysSelectFields.default'?: string[];
+    'alwaysSelectFields.list'?: string[];
+    'alwaysSelectFields.create'?: string[];
+    'alwaysSelectFields.read'?: string[];
+    'alwaysSelectFields.update'?: string[];
+    'docPermissions.default'?: ModelDocPermissionsHook;
+    'docPermissions.list'?: ModelDocPermissionsHook;
+    'docPermissions.create'?: ModelDocPermissionsHook;
+    'docPermissions.read'?: ModelDocPermissionsHook;
+    'docPermissions.update'?: ModelDocPermissionsHook;
+    'baseFilter.default'?: ModelBaseFilterHook;
+    'baseFilter.list'?: ModelBaseFilterHook;
+    'baseFilter.read'?: ModelBaseFilterHook;
+    'baseFilter.update'?: ModelBaseFilterHook;
+    'baseFilter.delete'?: ModelBaseFilterHook;
+    'overrideFilter.default'?: ModelOverrideFilterHook;
+    'overrideFilter.list'?: ModelOverrideFilterHook;
+    'overrideFilter.read'?: ModelOverrideFilterHook;
+    'overrideFilter.update'?: ModelOverrideFilterHook;
+    'overrideFilter.delete'?: ModelOverrideFilterHook;
+    'decorate.default'?: ModelHook;
+    'decorate.list'?: ModelHook;
+    'decorate.create'?: ModelHook;
+    'decorate.read'?: ModelHook;
+    'decorate.update'?: ModelHook;
+    'decorateAll.default'?: ModelListHook;
+    'decorateAll.list'?: ModelListHook;
+    'validate.default'?: ValidateRule | ModelValidateHook;
+    'validate.create'?: ValidateRule | ModelValidateHook;
+    'validate.update'?: ValidateRule | ModelValidateHook;
+    'prepare.default'?: ModelHook;
+    'prepare.create'?: ModelHook;
+    'prepare.update'?: ModelHook;
+    'transform.default'?: ModelDocumentHook;
+    'transform.update'?: ModelDocumentHook;
+    'afterPersist.default'?: ModelDocumentHook;
+    'afterPersist.create'?: ModelDocumentHook;
+    'afterPersist.update'?: ModelDocumentHook;
+    onChange?: Record<string, ModelChangeHook>;
+    'requestSchemas.create'?: RequestSchema;
+    'requestSchemas.update'?: RequestSchema;
+    'requestSchemas.upsert'?: RequestSchema;
+    'requestSchemas.count'?: RequestSchema;
+    'requestSchemas.distinct'?: RequestSchema;
+    'requestSchemas.advancedList'?: RequestSchema;
+    'requestSchemas.advancedReadFilter'?: RequestSchema;
+    'requestSchemas.advancedRead'?: RequestSchema;
+    'requestSchemas.advancedCreate.default'?: RequestSchema;
+    'requestSchemas.advancedCreate.data'?: RequestSchema;
+    'requestSchemas.advancedUpdate'?: RequestSchema;
+    'requestSchemas.advancedUpdate.default'?: RequestSchema;
+    'requestSchemas.advancedUpdate.data'?: RequestSchema;
+    'requestSchemas.advancedUpsert.default'?: RequestSchema;
+    'requestSchemas.advancedUpsert.data'?: RequestSchema;
+    'requestSchemas.subList'?: RequestSchema;
+    'requestSchemas.subRead'?: RequestSchema;
+    'requestSchemas.subCreate'?: RequestSchema;
+    'requestSchemas.subUpdate'?: RequestSchema;
+    'requestSchemas.subBulkUpdate'?: RequestSchema;
+    'defaults.findOneArgs'?: DefaultFindOneArgs<TModel>;
+    'defaults.findOneOptions'?: FindOneOptions;
+    'defaults.findByIdArgs'?: DefaultFindByIdArgs<TModel>;
+    'defaults.findByIdOptions'?: FindByIdOptions;
+    'defaults.findArgs'?: DefaultFindArgs<TModel>;
+    'defaults.findOptions'?: FindOptions;
+    'defaults.createArgs'?: CreateArgs;
+    'defaults.createOptions'?: CreateOptions;
+    'defaults.updateOneArgs'?: UpdateOneArgs<TModel>;
+    'defaults.updateOneOptions'?: UpdateOneOptions;
+    'defaults.updateByIdArgs'?: UpdateByIdArgs<TModel>;
+    'defaults.updateByIdOptions'?: UpdateByIdOptions;
+    'defaults.upsertArgs'?: UpsertArgs<TModel>;
+    'defaults.existsOptions'?: ExistsOptions;
+    'defaults.publicListArgs'?: PublicListArgs;
+    'defaults.publicListOptions'?: PublicListOptions;
+    'defaults.publicCreateArgs'?: PublicCreateArgs;
+    'defaults.publicCreateOptions'?: PublicCreateOptions;
+    'defaults.publicReadArgs'?: PublicReadArgs;
+    'defaults.publicReadOptions'?: PublicReadOptions;
+    'defaults.publicUpdateArgs'?: PublicUpdateArgs;
+    'defaults.publicUpdateOptions'?: PublicUpdateOptions;
+}
+interface ExtendedDataRouterOptions<TData = unknown> extends DataRouterOptions<TData> {
+    'requestSchemas.advancedList'?: RequestSchema;
+    'requestSchemas.advancedReadFilter'?: RequestSchema;
+    'requestSchemas.advancedRead'?: RequestSchema;
+}
+
+interface DistinctArgs<T = unknown> {
+    filter?: Filter<T>;
 }
 
 declare function macl(): (req: AccessRouterBaseRequest, res: Response, next: NextFunction) => Promise<void>;
 interface GuardModelConditionID {
-    type: string;
+    type: 'param' | 'query';
     key: string;
 }
 interface GuardModelCondition {
@@ -127,10 +1248,10 @@ interface GuardModelCondition {
     id: string | GuardModelConditionID;
     condition: string | string[];
 }
-declare function guard(condition: string): any;
-declare function guard(conditions: string[]): any;
-declare function guard(conditionFunc: GuardHook<ModelRequest>): any;
-declare function guard(modelCondition: GuardModelCondition): any;
+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;
@@ -334,8 +1455,6 @@ declare class RootRouter {
     get routes(): Router;
 }
 
-declare function createOpenApiRouter(runtime: AccessRuntime, options?: OpenApiRouterOptions): Router;
-
 type AccessRouterInstance = ModelRouter<any> | DataRouter<any> | RootRouter;
 type CombinedRouteInput = Router | AccessRouterInstance;
 declare function combineRoutes(...inputs: CombinedRouteInput[]): Router;
@@ -357,6 +1476,30 @@ declare const setDefaultModelOption: <K extends keyof ExtendedDefaultModelRouter
 declare const getDefaultModelOptions: () => DefaultModelRouterOptions<unknown>;
 declare const getDefaultModelOption: <K extends keyof ExtendedDefaultModelRouterOptions>(key: K, defaultValue?: ExtendedDefaultModelRouterOptions[K]) => ExtendedDefaultModelRouterOptions<unknown>[K];
 
+/**
+ * Wraps a request validator into a request schema adapter used by `access-router`.
+ *
+ * @example
+ * const schema = defineRequestSchema(fromZod(z.object({ name: z.string() })));
+ */
+declare function defineRequestSchema<T = unknown>(validator: RequestSchemaValidator<T>, options?: RequestSchemaOptions): RequestSchemaAdapter<T>;
+/**
+ * Adapts a Zod schema into a `RequestSchemaValidator` for `access-router`.
+ *
+ * @example
+ * const validator = fromZod(z.object({ name: z.string() }));
+ */
+declare function fromZod<TSchema extends z.ZodTypeAny>(schema: TSchema): RequestSchemaValidator<z.output<TSchema>>;
+declare function fromStandardSchema<TSchema extends StandardSchemaV1>(schema: TSchema): RequestSchemaValidator<StandardSchemaInferOutput<TSchema>>;
+declare function fromYup<TSchema extends YupSchemaLike>(schema: TSchema): RequestSchemaValidator;
+declare function fromJoi<TSchema extends JoiSchemaLike>(schema: TSchema): RequestSchemaValidator;
+declare function fromAjv<TValue = unknown>(validator: AjvValidatorLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromValibot<TSchema, TOutput = unknown>(schema: TSchema, safeParse: ValibotSafeParseLike): RequestSchemaValidator<TOutput>;
+declare function fromArkType<TValue = unknown>(type: ArkTypeLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromIoTs<TValue = unknown>(decoder: IoTsDecoderLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromSuperstruct<TStruct, TOutput = unknown>(struct: TStruct, validate: SuperstructValidateLike): RequestSchemaValidator<TOutput>;
+declare function fromVine<TValue = unknown>(validator: VineValidatorLike<TValue>): RequestSchemaValidator<TValue>;
+
 interface Options {
     virtualPermissionField?: string;
     modelName: string;
@@ -407,4 +1550,4 @@ type AccessRuntimeApi = typeof macl & Wtt;
 declare function createAccessRuntime(): AccessRuntimeApi;
 declare const acl: AccessRuntimeApi;
 
-export { AccessRuntime, type AccessRuntimeApi, type CombinedRouteInput, DataRouter, DataRouterOptions, GlobalOptions, ModelRouter, ModelRouterOptions, type OpenApiDocumentOptions, type OpenApiMethod, type OpenApiRouteDescriptor, type OpenApiRouterOptions, RootRouter, RootRouterOptions, acl, combineRoutes, createAccessRuntime, createOpenApiRouter, acl as default, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, permissionsPlugin, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions };
+export { type AccessRouterPermissionMap, type AccessRouterPermissions, type AccessRouterRequest, type AccessRouterRequestExtensions, AccessRuntime, type AccessRuntimeApi, type AjvErrorObjectLike, type AjvValidatorLike, type ArkTypeErrorsLike, type ArkTypeLike, type CombinedRouteInput, DataRouter, type DataRouterOptions, type GlobalOptions, type IoTsContextEntryLike, type IoTsDecodeErrorLike, type IoTsDecoderLike, type JoiSchemaLike, type JoiValidationErrorDetailLike, ModelRouter, type ModelRouterOptions, type OpenApiDocumentOptions, type OpenApiMethod, type OpenApiRouteDescriptor, type OpenApiRouterOptions, type Permissions, type RequestSchemaAdapter, type RequestSchemaFailure, type RequestSchemaIssue, type RequestSchemaLike, type RequestSchemaOptions, type RequestSchemaResult, type RequestSchemaSuccess, type RequestSchemaValidator, RootRouter, type RootRouterOptions, type StandardSchemaFailure, type StandardSchemaInferOutput, type StandardSchemaIssue, type StandardSchemaPathSegment, type StandardSchemaResult, type StandardSchemaSuccess, type StandardSchemaV1, type SuperstructFailureLike, type SuperstructValidateLike, type ValibotIssueLike, type ValibotPathItemLike, type ValibotSafeParseLike, type ValibotSafeParseResult, type VineValidationErrorLike, type VineValidationMessageLike, type VineValidatorLike, type YupSchemaLike, type YupValidationErrorLike, acl, combineRoutes, createAccessRuntime, createOpenApiRouter, acl as default, defineRequestSchema, fromAjv, fromArkType, fromIoTs, fromJoi, fromStandardSchema, fromSuperstruct, fromValibot, fromVine, fromYup, fromZod, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, permissionsPlugin, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions };