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

package/service-DLKAswCS.d.mts

@@ -0,0 +1,1117 @@
+import { z } from 'zod';
+import express from 'express';
+import mongoose from 'mongoose';
+import { Diff } from 'deep-diff';
+
+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>;
+
+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 RequestZodSchema = z.ZodTypeAny;
+type SubRouteGuardOptions = Record<string, Validation | Record<string, Validation>>;
+interface RequestSchemas {
+    create?: RequestZodSchema;
+    update?: RequestZodSchema;
+    upsert?: RequestZodSchema;
+    count?: RequestZodSchema;
+    distinct?: RequestZodSchema;
+    advancedList?: RequestZodSchema;
+    advancedReadFilter?: RequestZodSchema;
+    advancedRead?: RequestZodSchema;
+    advancedCreate?: RequestZodSchema;
+    advancedCreateData?: RequestZodSchema;
+    advancedUpdate?: RequestZodSchema;
+    advancedUpdateData?: RequestZodSchema;
+    advancedUpsert?: RequestZodSchema;
+    advancedUpsertData?: RequestZodSchema;
+    subList?: RequestZodSchema;
+    subRead?: RequestZodSchema;
+    subCreate?: RequestZodSchema;
+    subUpdate?: RequestZodSchema;
+    subBulkUpdate?: RequestZodSchema;
+}
+interface DataRequestSchemas {
+    advancedList?: RequestZodSchema;
+    advancedReadFilter?: RequestZodSchema;
+    advancedRead?: RequestZodSchema;
+}
+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'?: RequestZodSchema;
+    'requestSchemas.update'?: RequestZodSchema;
+    'requestSchemas.upsert'?: RequestZodSchema;
+    'requestSchemas.count'?: RequestZodSchema;
+    'requestSchemas.distinct'?: RequestZodSchema;
+    'requestSchemas.advancedList'?: RequestZodSchema;
+    'requestSchemas.advancedReadFilter'?: RequestZodSchema;
+    'requestSchemas.advancedRead'?: RequestZodSchema;
+    'requestSchemas.advancedCreate.default'?: RequestZodSchema;
+    'requestSchemas.advancedCreate.data'?: RequestZodSchema;
+    'requestSchemas.advancedUpdate'?: RequestZodSchema;
+    'requestSchemas.advancedUpdate.default'?: RequestZodSchema;
+    'requestSchemas.advancedUpdate.data'?: RequestZodSchema;
+    'requestSchemas.advancedUpsert.default'?: RequestZodSchema;
+    'requestSchemas.advancedUpsert.data'?: RequestZodSchema;
+    'requestSchemas.subList'?: RequestZodSchema;
+    'requestSchemas.subRead'?: RequestZodSchema;
+    'requestSchemas.subCreate'?: RequestZodSchema;
+    'requestSchemas.subUpdate'?: RequestZodSchema;
+    'requestSchemas.subBulkUpdate'?: RequestZodSchema;
+    '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'?: RequestZodSchema;
+    'requestSchemas.advancedReadFilter'?: RequestZodSchema;
+    'requestSchemas.advancedRead'?: RequestZodSchema;
+}
+
+interface DistinctArgs<T = unknown> {
+    filter?: Filter<T>;
+}
+
+export { type GlobalPermissionValue as $, type AccessRouterBaseRequest as A, type BaseFilterAccess as B, Codes as C, type DataBaseFilterHook as D, type DefaultModelRouterOptions as E, type Filter as F, type Defaults as G, type DistinctArgs as H, type Include as I, type DocPermissionsAccess as J, type ErrorResult as K, type ExistsOptions as L, type ExtendedDataRouterOptions as M, type ExtendedDefaultModelRouterOptions as N, type ExtendedModelRouterOptions as O, type Projection as P, FilterOperator as Q, type FindAccess as R, type Sort as S, type Task as T, type FindArgs as U, type FindByIdArgs as V, type FindByIdOptions as W, type FindOneArgs as X, type FindOneOptions as Y, type FindOptions as Z, type GlobalOptions as _, type Populate as a, type SelectAccess as a$, type GuardHook as a0, type IdentifierHook as a1, type KeyValueProjection as a2, type ListResult as a3, type MaybePromise as a4, type ModelBaseFilterHook as a5, type ModelChangeHook as a6, type ModelDeleteHook as a7, type ModelDocPermissionsHook as a8, type ModelDocument as a9, type RootDataListQueryEntry as aA, type RootDataOperation as aB, type RootDataReadByFilterQueryEntry as aC, type RootDataReadByIdQueryEntry as aD, type RootModelCountQueryEntry as aE, type RootModelCreateQueryEntry as aF, type RootModelDeleteQueryEntry as aG, type RootModelDistinctQueryEntry as aH, type RootModelListQueryEntry as aI, type RootModelNewQueryEntry as aJ, type RootModelOperation as aK, type RootModelReadByFilterQueryEntry as aL, type RootModelReadByIdQueryEntry as aM, type RootModelSubBulkUpdateQueryEntry as aN, type RootModelSubCreateQueryEntry as aO, type RootModelSubDeleteQueryEntry as aP, type RootModelSubListQueryEntry as aQ, type RootModelSubReadQueryEntry as aR, type RootModelSubUpdateQueryEntry as aS, type RootModelUpdateQueryEntry as aT, type RootModelUpsertQueryEntry as aU, type RootOperationResult as aV, type RootQueryEntry as aW, type RootRouterOptions as aX, type RootSubOperation as aY, type RootTarget as aZ, type RouteGuardAccess as a_, type ModelDocumentHook as aa, type ModelHook as ab, type ModelHookContext as ac, type ModelIdentifierHook as ad, type ModelListHook as ae, type ModelOverrideFilterHook as af, type ModelRequest as ag, type ModelRouterOptions as ah, type ModelValidateHook as ai, type PathValue as aj, type PermissionSchema as ak, type PopulateAccess as al, type PrepareAccess as am, type PublicCreateArgs as an, type PublicCreateOptions as ao, type PublicListArgs as ap, type PublicListOptions as aq, type PublicOutput as ar, type PublicReadArgs as as, type PublicReadOptions as at, type PublicUpdateArgs as au, type PublicUpdateOptions as av, type PublicUpsertArgs as aw, type PublicUpsertOptions as ax, type Request as ay, type RequestSchemas as az, type SubPopulate as b, type SelectedPopulatedPublicOutput as b0, type SelectedPublicOutput as b1, type ServiceResult as b2, type SingleResult as b3, type SortOrder as b4, StatusCodes as b5, type SubQueryEntry as b6, type TransformAccess as b7, type TypedFilter as b8, type UpdateByIdArgs as b9, type UpdateByIdOptions as ba, type UpdateOneArgs as bb, type UpdateOneOptions as bc, type UpsertArgs as bd, type UpsertOptions as be, type ValidateAccess as bf, type ValidateRule as bg, type Validation as bh, DataService as bi, Model as bj, Service as bk, PublicService as bl, type AccessRouterPermissionMap as bm, type AccessRouterPermissions as bn, type Permissions as bo, type AccessRouterFieldKey as c, type AccessRouterLogger as d, type AccessRouterRequest as e, type AccessRouterRequestExtensions as f, type AfterPersistAccess as g, type CreateArgs as h, type CreateOptions as i, CustomHeaders as j, type DataFilter as k, type DataFindArgs as l, type DataFindOneArgs as m, type DataFindOneOptions as n, type DataFindOptions as o, type DataHook as p, type DataHookContext as q, type DataIdentifierHook as r, type DataListHook as s, type DataOverrideFilterHook as t, type DataRequest as u, type DataRequestSchemas as v, type DataRouterOptions as w, type DecorateAccess as x, type DecorateAllAccess as y, type DeepFieldPath as z };