@web-ts-toolkit/access-router 0.2.0 → 0.4.0

package/parsers-CsyGHYQR.d.mts

@@ -0,0 +1,1418 @@
+import { z } from 'zod';
+import mongoose from 'mongoose';
+import { Diff } from 'deep-diff';
+import express from 'express';
+
+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): any;
+    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> {
+    req: ModelRequest;
+    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: any[];
+        includePaths: any[];
+    };
+    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", {}>;
+    findOneAndDelete(filter: any): mongoose.Query<any, any, {}, any, "findOneAndDelete", {}>;
+    exists(filter: any): mongoose.Query<any, any, {}, any, "findOne", {}>;
+    countDocuments(filter?: {}): mongoose.Query<number, any, {}, any, "countDocuments", {}>;
+    estimatedDocumentCount(): mongoose.Query<number, any, {}, any, "estimatedDocumentCount", {}>;
+    distinct(field: string, conditions?: {}): mongoose.Query<any[], any, {}, any, "distinct", {}>;
+}
+
+declare class Service<TModel = unknown> extends Base<TModel> {
+    model: Model;
+    options: ModelRouterOptions<TModel>;
+    defaults: Defaults<TModel>;
+    baseFields: string[];
+    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: any): 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> {
+    req: DataRequest;
+    dataName: string;
+    options: DataRouterOptions<T>;
+    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 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<any>;
+    isAllowed(modelName: string, access: RouteGuardAccess | string): Promise<any>;
+    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<any>;
+    isAllowed(dataName: string, access: RouteGuardAccess | string): Promise<any>;
+    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 StatusCodes {
+    OK = 200,
+    Created = 201,
+    BadRequest = 400,
+    Unauthorized = 401,
+    Forbidden = 403,
+    NotFound = 404,
+    UnprocessableContent = 422
+}
+declare enum Codes {
+    Success = "success",
+    Created = "created",
+    BadRequest = "bad_request",
+    Unauthorized = "unauthorized",
+    Forbidden = "forbidden",
+    NotFound = "not_found"
+}
+declare enum CustomHeaders {
+    TotalCount = "wtt-total-count",
+    ReturnedCount = "wtt-returned-count",
+    Page = "wtt-page",
+    PageSize = "wtt-page-size",
+    TotalPages = "wtt-total-pages",
+    HasNextPage = "wtt-has-next-page",
+    HasPreviousPage = "wtt-has-previous-page"
+}
+declare enum FilterOperator {
+    SubQuery = 0,
+    Date = 1
+}
+
+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 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?: Diff<unknown>[];
+    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;
+    };
+}
+type RootTarget = 'model' | 'data';
+type RootSubOperation = 'subList' | 'subRead' | 'subCreate' | 'subUpdate' | 'subBulkUpdate' | 'subDelete';
+type RootModelOperation = 'new' | 'list' | 'read' | 'create' | 'update' | 'upsert' | 'delete' | 'distinct' | 'count' | RootSubOperation;
+type RootDataOperation = 'list' | 'read';
+interface RootQueryEntryBase<TTarget extends RootTarget, TOp extends string> {
+    target: TTarget;
+    name: string;
+    op: TOp;
+    order?: number;
+}
+interface RootModelNewQueryEntry extends RootQueryEntryBase<'model', 'new'> {
+}
+interface RootModelListQueryEntry extends RootQueryEntryBase<'model', 'list'> {
+    filter?: Filter;
+    args?: PublicListArgs;
+    options?: PublicListOptions;
+}
+interface RootModelReadByIdQueryEntry extends RootQueryEntryBase<'model', 'read'> {
+    id: string;
+    args?: PublicReadArgs;
+    options?: PublicReadOptions;
+}
+interface RootModelReadByFilterQueryEntry extends RootQueryEntryBase<'model', 'read'> {
+    filter: Filter;
+    args?: PublicReadArgs & {
+        sort?: Sort;
+    };
+    options?: PublicReadOptions;
+}
+interface RootModelCreateQueryEntry extends RootQueryEntryBase<'model', 'create'> {
+    data: unknown;
+    args?: PublicCreateArgs;
+    options?: PublicCreateOptions;
+}
+interface RootModelUpdateQueryEntry extends RootQueryEntryBase<'model', 'update'> {
+    id: string;
+    data: unknown;
+    args?: PublicUpdateArgs;
+    options?: PublicUpdateOptions;
+}
+interface RootModelUpsertQueryEntry extends RootQueryEntryBase<'model', 'upsert'> {
+    data: Record<string, unknown>;
+    args?: PublicUpsertArgs;
+    options?: PublicUpsertOptions;
+}
+interface RootModelDeleteQueryEntry extends RootQueryEntryBase<'model', 'delete'> {
+    id: string;
+}
+interface RootModelSubListQueryEntry extends RootQueryEntryBase<'model', 'subList'> {
+    id: string;
+    sub: string;
+    filter?: Filter;
+    args?: {
+        select?: string[];
+    };
+}
+interface RootModelSubReadQueryEntry extends RootQueryEntryBase<'model', 'subRead'> {
+    id: string;
+    sub: string;
+    subId: string;
+    args?: {
+        select?: string[];
+        populate?: SubPopulate | SubPopulate[] | string | string[];
+    };
+}
+interface RootModelSubCreateQueryEntry extends RootQueryEntryBase<'model', 'subCreate'> {
+    id: string;
+    sub: string;
+    data: unknown;
+}
+interface RootModelSubUpdateQueryEntry extends RootQueryEntryBase<'model', 'subUpdate'> {
+    id: string;
+    sub: string;
+    subId: string;
+    data: unknown;
+}
+interface RootModelSubBulkUpdateQueryEntry extends RootQueryEntryBase<'model', 'subBulkUpdate'> {
+    id: string;
+    sub: string;
+    data: unknown;
+}
+interface RootModelSubDeleteQueryEntry extends RootQueryEntryBase<'model', 'subDelete'> {
+    id: string;
+    sub: string;
+    subId: string;
+}
+interface RootModelDistinctQueryEntry extends RootQueryEntryBase<'model', 'distinct'> {
+    field: string;
+    filter?: Filter;
+}
+interface RootModelCountQueryEntry extends RootQueryEntryBase<'model', 'count'> {
+    filter?: Filter;
+    options?: {
+        access?: BaseFilterAccess;
+        [key: string]: unknown;
+    };
+}
+interface RootDataListQueryEntry extends RootQueryEntryBase<'data', 'list'> {
+    filter?: Filter;
+    args?: DataFindArgs;
+    options?: {
+        includeCount?: boolean;
+        [key: string]: unknown;
+    };
+}
+interface RootDataReadByIdQueryEntry extends RootQueryEntryBase<'data', 'read'> {
+    id: string;
+    args?: DataFindOneArgs;
+}
+interface RootDataReadByFilterQueryEntry extends RootQueryEntryBase<'data', 'read'> {
+    filter: Filter;
+    args?: DataFindOneArgs;
+}
+type RootQueryEntry = RootModelNewQueryEntry | RootModelListQueryEntry | RootModelReadByIdQueryEntry | RootModelReadByFilterQueryEntry | RootModelCreateQueryEntry | RootModelUpdateQueryEntry | RootModelUpsertQueryEntry | RootModelDeleteQueryEntry | RootModelSubListQueryEntry | RootModelSubReadQueryEntry | RootModelSubCreateQueryEntry | RootModelSubUpdateQueryEntry | RootModelSubBulkUpdateQueryEntry | RootModelSubDeleteQueryEntry | RootModelDistinctQueryEntry | RootModelCountQueryEntry | RootDataListQueryEntry | RootDataReadByIdQueryEntry | RootDataReadByFilterQueryEntry;
+interface RootOperationResult<T = unknown, TError = unknown, TInput = unknown, TQuery = unknown> {
+    index: number;
+    target: RootTarget;
+    name: string;
+    op: RootModelOperation | RootDataOperation;
+    result: ServiceResult<T, TError, TInput, TQuery>;
+    statusCode: number;
+    message: string;
+}
+interface SubQueryEntry {
+    model: string;
+    op: 'list' | 'read' | string;
+    id?: string;
+    filter?: Filter;
+    args?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+    sqOptions?: {
+        path?: string;
+        compact?: boolean;
+    };
+}
+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;
+}
+type Request = AccessRouterBaseRequest;
+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: Diff<unknown>[], 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 ValidationError = {
+    detail: string;
+    pointer?: string;
+    parameter?: string;
+};
+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>;
+};
+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;
+};
+type ListQueryInput = {
+    skip?: string;
+    limit?: string;
+    page?: string;
+    page_size?: string;
+    skim?: 'true' | 'false';
+    include_permissions?: 'true' | 'false';
+    include_count?: 'true' | 'false';
+    include_extra_headers?: 'true' | 'false';
+};
+type CreateQueryInput = {
+    include_permissions?: 'true' | 'false';
+};
+type ReadQueryInput = {
+    include_permissions?: 'true' | 'false';
+    try_list?: 'true' | 'false';
+};
+type UpdateQueryInput = {
+    returning_all?: 'true' | 'false';
+};
+type UpsertQueryInput = {
+    returning_all?: 'true' | 'false';
+    include_permissions?: 'true' | 'false';
+};
+type AdvancedListBody = {
+    filter?: Filter | unknown[];
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        includeCount?: boolean;
+        includeExtraHeaders?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type CountBody = {
+    filter?: Filter | unknown[];
+    options?: {
+        access?: unknown;
+    };
+};
+type AdvancedReadFilterBody = {
+    filter?: Filter | unknown[];
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        tryList?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedReadBody = {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        tryList?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedCreateBody = {
+    data: unknown;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedUpdateBody = {
+    data: unknown;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        returningAll?: boolean;
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedUpsertBody = {
+    data: Record<string, unknown>;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        returningAll?: boolean;
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type DistinctBody = {
+    filter?: Filter | unknown[];
+};
+type SubListBody = {
+    filter?: Filter;
+    select?: string[];
+};
+type SubReadBody = {
+    select?: string[];
+    populate?: SubPopulate | SubPopulate[] | string | string[];
+};
+
+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 parsePathParam(value: string | string[] | undefined, parameter: string): string;
+declare function parseQuery<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+declare function parseBody<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+declare function parseBodyWithSchema<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown, userSchema?: RequestSchemaLike): Promise<z.output<TSchema>>;
+declare function parseNestedBodyWithSchema(schema: z.ZodTypeAny, value: unknown, nestedKey: string, userSchema?: RequestSchemaLike): Promise<Record<string, unknown>>;
+declare function defineRequestSchema<T = unknown>(validator: RequestSchemaValidator<T>): RequestSchemaValidator<T>;
+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>;
+
+export { type FindAccess as $, type AccessRouterBaseRequest as A, type BaseFilterAccess as B, Codes as C, type DataBaseFilterHook as D, type DataHook as E, type DataHookContext as F, type DataIdentifierHook as G, type DataListHook as H, type DataOverrideFilterHook as I, type DataRequest as J, type DataRequestSchemas as K, type DataRouterOptions as L, type DecorateAccess as M, type DecorateAllAccess as N, type DeepFieldPath as O, type DefaultModelRouterOptions as P, type Defaults as Q, type DistinctArgs as R, type DistinctBody as S, type DocPermissionsAccess as T, type ErrorResult as U, type ExistsOptions as V, type ExtendedDataRouterOptions as W, type ExtendedDefaultModelRouterOptions as X, type ExtendedModelRouterOptions as Y, type Filter as Z, FilterOperator as _, type AccessRouterFieldKey as a, type RootDataReadByFilterQueryEntry as a$, type FindArgs as a0, type FindByIdArgs as a1, type FindByIdOptions as a2, type FindOneArgs as a3, type FindOneOptions as a4, type FindOptions as a5, type GlobalOptions as a6, type GlobalPermissionValue as a7, type GuardHook as a8, type IdentifierHook as a9, type Populate as aA, type PopulateAccess as aB, type PrepareAccess as aC, type Projection as aD, type PublicCreateArgs as aE, type PublicCreateOptions as aF, type PublicListArgs as aG, type PublicListOptions as aH, type PublicOutput as aI, type PublicReadArgs as aJ, type PublicReadOptions as aK, type PublicUpdateArgs as aL, type PublicUpdateOptions as aM, type PublicUpsertArgs as aN, type PublicUpsertOptions as aO, type ReadQueryInput as aP, type Request as aQ, type RequestSchemaAdapter as aR, type RequestSchemaFailure as aS, type RequestSchemaIssue as aT, type RequestSchemaLike as aU, type RequestSchemaResult as aV, type RequestSchemaSuccess as aW, type RequestSchemaValidator as aX, type RequestSchemas as aY, type RootDataListQueryEntry as aZ, type RootDataOperation as a_, type Include as aa, type IoTsContextEntryLike as ab, type IoTsDecodeErrorLike as ac, type IoTsDecoderLike as ad, type JoiSchemaLike as ae, type JoiValidationErrorDetailLike as af, type KeyValueProjection as ag, type ListQueryInput as ah, type ListResult as ai, type MaybePromise as aj, type ModelBaseFilterHook as ak, type ModelChangeHook as al, type ModelDeleteHook as am, type ModelDocPermissionsHook as an, type ModelDocument as ao, type ModelDocumentHook as ap, type ModelHook as aq, type ModelHookContext as ar, type ModelIdentifierHook as as, type ModelListHook as at, type ModelOverrideFilterHook as au, type ModelRequest as av, type ModelRouterOptions as aw, type ModelValidateHook as ax, type PathValue as ay, type PermissionSchema as az, type AccessRouterLogger as b, type ValidationError as b$, type RootDataReadByIdQueryEntry as b0, type RootModelCountQueryEntry as b1, type RootModelCreateQueryEntry as b2, type RootModelDeleteQueryEntry as b3, type RootModelDistinctQueryEntry as b4, type RootModelListQueryEntry as b5, type RootModelNewQueryEntry as b6, type RootModelOperation as b7, type RootModelReadByFilterQueryEntry as b8, type RootModelReadByIdQueryEntry as b9, type StandardSchemaSuccess as bA, type StandardSchemaV1 as bB, StatusCodes as bC, type SubListBody as bD, type SubPopulate as bE, type SubQueryEntry as bF, type SubReadBody as bG, type SuperstructFailureLike as bH, type SuperstructValidateLike as bI, type Task as bJ, type TransformAccess as bK, type TypedFilter as bL, type UpdateByIdArgs as bM, type UpdateByIdOptions as bN, type UpdateOneArgs as bO, type UpdateOneOptions as bP, type UpdateQueryInput as bQ, type UpsertArgs as bR, type UpsertOptions as bS, type UpsertQueryInput as bT, type ValibotIssueLike as bU, type ValibotPathItemLike as bV, type ValibotSafeParseLike as bW, type ValibotSafeParseResult as bX, type ValidateAccess as bY, type ValidateRule as bZ, type Validation as b_, type RootModelSubBulkUpdateQueryEntry as ba, type RootModelSubCreateQueryEntry as bb, type RootModelSubDeleteQueryEntry as bc, type RootModelSubListQueryEntry as bd, type RootModelSubReadQueryEntry as be, type RootModelSubUpdateQueryEntry as bf, type RootModelUpdateQueryEntry as bg, type RootModelUpsertQueryEntry as bh, type RootOperationResult as bi, type RootQueryEntry as bj, type RootRouterOptions as bk, type RootSubOperation as bl, type RootTarget as bm, type RouteGuardAccess as bn, type SelectAccess as bo, type SelectedPopulatedPublicOutput as bp, type SelectedPublicOutput as bq, type ServiceResult as br, type SingleResult as bs, type Sort as bt, type SortOrder as bu, type StandardSchemaFailure as bv, type StandardSchemaInferOutput as bw, type StandardSchemaIssue as bx, type StandardSchemaPathSegment as by, type StandardSchemaResult as bz, type AccessRouterRequest as c, type VineValidationErrorLike as c0, type VineValidationMessageLike as c1, type VineValidatorLike as c2, type YupSchemaLike as c3, type YupValidationErrorLike as c4, defineRequestSchema as c5, fromAjv as c6, fromArkType as c7, fromIoTs as c8, fromJoi as c9, fromStandardSchema as ca, fromSuperstruct as cb, fromValibot as cc, fromVine as cd, fromYup as ce, fromZod as cf, parseBody as cg, parseBodyWithSchema as ch, parseNestedBodyWithSchema as ci, parsePathParam as cj, parseQuery as ck, DataService as cl, Model as cm, Service as cn, PublicService as co, type AccessRouterPermissionMap as cp, type AccessRouterPermissions as cq, type Permissions as cr, type AccessRouterRequestExtensions as d, type AdvancedCreateBody as e, type AdvancedListBody as f, type AdvancedReadBody as g, type AdvancedReadFilterBody as h, type AdvancedUpdateBody as i, type AdvancedUpsertBody as j, type AfterPersistAccess as k, type AjvErrorObjectLike as l, type AjvValidatorLike as m, type ArkTypeErrorsLike as n, type ArkTypeLike as o, type ArkTypeProblemLike as p, type CountBody as q, type CreateArgs as r, type CreateOptions as s, type CreateQueryInput as t, CustomHeaders as u, type DataFilter as v, type DataFindArgs as w, type DataFindOneArgs as x, type DataFindOneOptions as y, type DataFindOptions as z };