@web-ts-toolkit/access-router 0.2.0

package/index.d.ts

@@ -0,0 +1,1589 @@
+import express, { Response, NextFunction, Router } from 'express';
+import mongoose, { Document } from 'mongoose';
+import { Diff } from 'deep-diff';
+import { z } from 'zod';
+import JsonRouter from '@web-ts-toolkit/express-json-router';
+
+interface BooleanObject {
+    [key: string]: boolean;
+}
+declare class Permission {
+    $_permissions: BooleanObject;
+    $_permissionKeys: string[];
+    constructor(permissions: BooleanObject);
+    prop(permission: string): boolean;
+    has(permission: string): boolean;
+    hasAny(permissions: string[]): boolean;
+    hasAll(permissions: string[]): boolean;
+    any(permissions: string[]): boolean;
+    all(permissions: string[]): boolean;
+}
+
+interface Permissions extends Permission {
+    [key: string]: any;
+}
+
+declare class Base {
+    req: Request;
+    modelName: string;
+    constructor(req: Request, modelName: string);
+    decorate<T>(doc: T, access: DecorateAccess, context: MiddlewareContext): Promise<T>;
+    decorateAll<T>(docs: T[], access: DecorateAllAccess, context: MiddlewareContext): Promise<T[]>;
+    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    genDocPermissions(doc: unknown, access: DocPermissionsAccess, context: MiddlewareContext): Promise<Record<string, unknown>>;
+    genFilter(access?: BaseFilterAccess, filter?: any): Promise<Filter>;
+    getIdentifier(): string | null;
+    genIDFilter(id: string): Promise<Filter>;
+    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: MiddlewareContext): Promise<T>;
+    addFieldPermissions<T extends {
+        _id?: unknown;
+    }>(doc: T, access: DocPermissionsAccess, context: MiddlewareContext): 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: MiddlewareContext): Promise<T>;
+    runTasks<T extends object>(docObject: T, tasks: Task | Task[]): T;
+    transform<T>(doc: T, access: TransformAccess, context: MiddlewareContext): Promise<T>;
+    finalize<T>(doc: T, access: FinalizeAccess, context: MiddlewareContext): Promise<T>;
+    changes(doc: Record<string, unknown>, context: MiddlewareContext): Promise<void>;
+    validate(allowedData: unknown, access: ValidateAccess, context: MiddlewareContext): 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(filter: any): Promise<unknown>;
+    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 extends Base {
+    model: Model;
+    options: ModelRouterOptions;
+    defaults: Defaults;
+    baseFields: string[];
+    baseFieldsExt: string[];
+    constructor(req: Request, modelName: string);
+    findOne(filter: Filter, args?: FindOneArgs, options?: FindOneOptions): Promise<SingleResult | ErrorResult>;
+    findById(id: string, args?: FindByIdArgs, options?: FindByIdOptions): Promise<SingleResult | ErrorResult>;
+    find(filter: Filter, args?: FindArgs, options?: FindOptions, decorate?: Function): Promise<ListResult | ErrorResult>;
+    create(data: any, args?: CreateArgs, options?: CreateOptions, decorate?: Function): Promise<ListResult | ErrorResult>;
+    new(): Promise<SingleResult>;
+    updateOne(filter: Filter, data: any, args?: UpdateOneArgs, options?: UpdateOneOptions, decorate?: Function): Promise<SingleResult | ErrorResult>;
+    updateById(id: string, data: any, { populate, overrides }?: UpdateByIdArgs, { skim, includePermissions, populateAccess, }?: UpdateByIdOptions, decorate?: Function): Promise<SingleResult | ErrorResult>;
+    upsert(filter: Filter, data: any, args?: UpsertArgs, options?: UpsertOptions, decorate?: Function): Promise<ServiceResult>;
+    delete(id: string): Promise<SingleResult | ErrorResult>;
+    exists(filter: Filter, options: ExistsOptions & {
+        includeId: true;
+    }): Promise<SingleResult | ErrorResult>;
+    exists(filter: Filter, options?: ExistsOptions): Promise<SingleResult<boolean> | ErrorResult>;
+    distinct(field: string, args?: DistinctArgs): Promise<ListResult | ErrorResult>;
+    count(filter: any, access?: BaseFilterAccess): Promise<SingleResult<number> | ErrorResult>;
+    getDocPermissions(doc: any): unknown;
+    private getFieldPermissionAccess;
+    private getAccessibleIdSet;
+    listSub(id: any, sub: any, options?: {
+        filter: Filter;
+        fields: string[];
+    }): Promise<ListResult | ErrorResult>;
+    readSub(id: any, sub: any, subId: any, options?: {
+        fields: 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 extends Service {
+    _list(filter: Filter, args?: PublicListArgs, options?: PublicListOptions): Promise<ListResult | ErrorResult>;
+    _create(data: any, args?: PublicCreateArgs, options?: PublicCreateOptions): Promise<ListResult | ErrorResult>;
+    _new(): Promise<SingleResult>;
+    _read(id: string, args?: PublicReadArgs, options?: PublicReadOptions): Promise<SingleResult | ErrorResult>;
+    _readFilter(filter: Filter, args?: PublicReadArgs & {
+        sort?: Sort;
+    }, options?: PublicReadOptions): Promise<SingleResult | ErrorResult>;
+    _update(id: string, data: any, args?: PublicUpdateArgs, options?: PublicUpdateOptions): Promise<SingleResult | ErrorResult>;
+    _delete(id: string): Promise<SingleResult | ErrorResult>;
+    _distinct(field: string, options?: DistinctArgs): Promise<ListResult | ErrorResult>;
+    _count(filter: any, access?: BaseFilterAccess): Promise<SingleResult<number> | ErrorResult>;
+}
+
+declare class DataService<T> {
+    req: Request;
+    dataName: string;
+    options: DataRouterOptions;
+    data: T[];
+    constructor(req: Request, dataName: string);
+    findOne(filter: DataFilter, args?: DataFindOneArgs, options?: DataFindOneOptions): Promise<SingleResult<T> | ErrorResult>;
+    findById(id: string, args?: DataFindOneArgs, options?: DataFindOneOptions): Promise<SingleResult<T> | ErrorResult>;
+    find(filter: DataFilter, args?: DataFindArgs, options?: DataFindOptions): Promise<ListResult<T> | ErrorResult>;
+    decorate<TDoc>(doc: TDoc, access: DecorateAccess, context?: DataMiddlewareContext): Promise<TDoc>;
+    decorateAll<TDoc>(docs: TDoc[], access: DecorateAllAccess): Promise<TDoc[]>;
+    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    genFilter(access?: BaseFilterAccess, filter?: any): Promise<Filter>;
+    genIDFilter(id: string): Promise<Filter>;
+    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>;
+}
+
+declare class Core {
+    private req;
+    private caches;
+    constructor(req: Request);
+    getIdentifier(modelName: string): string;
+    genIDFilter(modelName: string, id: string): Promise<any>;
+    genFilter(modelName: string, access?: BaseFilterAccess, _filter?: Filter): Promise<Filter>;
+    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: MiddlewareContext): Promise<boolean | unknown[]>;
+    prepare<T>(modelName: string, allowedData: T, access: PrepareAccess, context: MiddlewareContext): Promise<T>;
+    transform<T>(modelName: string, doc: T, access: TransformAccess, context: MiddlewareContext): Promise<T>;
+    finalize<T>(modelName: string, doc: T, access: FinalizeAccess, context: MiddlewareContext): Promise<T>;
+    changes(modelName: string, doc: Record<string, unknown>, context: MiddlewareContext): Promise<void>;
+    genDocPermissions(modelName: string, doc: unknown, access: DocPermissionsAccess, context: MiddlewareContext): Promise<{}>;
+    addEmptyPermissions<T>(modelName: string, doc: T): T;
+    addDocPermissions<T>(modelName: string, doc: T, access: DocPermissionsAccess, context: MiddlewareContext): Promise<T>;
+    addFieldPermissions<T extends {
+        _id?: unknown;
+    }>(modelName: string, doc: T, access: DocPermissionsAccess, context: MiddlewareContext): Promise<T>;
+    decorate<T>(modelName: string, doc: T, access: DecorateAccess, context: MiddlewareContext): Promise<T>;
+    decorateAll<T>(modelName: string, docs: T[], access: DecorateAllAccess, context: MiddlewareContext): 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(modelName: string): Service;
+    getPublicService(modelName: string): PublicService;
+    service(modelName: string): PublicService;
+    svc(modelName: string): PublicService;
+    private getGlobalPermissions;
+}
+
+declare class DataCore {
+    private req;
+    private caches;
+    constructor(req: Request);
+    genIDFilter(dataName: string, id: string): Promise<any>;
+    genFilter(dataName: string, access?: BaseFilterAccess, _filter?: Filter): Promise<Filter>;
+    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?: DataMiddlewareContext): Promise<TDoc>;
+    decorateAll<TDoc>(dataName: string, docs: TDoc[], access: DecorateAllAccess): Promise<TDoc[]>;
+    getPermissions(): Permission;
+    setPermissions(): Promise<void>;
+    canActivate(routeGuard: Validation): Promise<any>;
+    isAllowed(dataName: string, access: RouteGuardAccess | string): Promise<any>;
+    getService(dataName: string): DataService<unknown>;
+    service(dataName: string): DataService<unknown>;
+    svc(dataName: string): DataService<unknown>;
+    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
+}
+
+type Validation = boolean | string | string[] | Function;
+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 Filter = false | Record<string, unknown>;
+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 MiddlewareContext {
+    modelName: string;
+    model: mongoose.Model<unknown>;
+    originalDocObject?: Record<string, unknown>;
+    finalDocObject?: Record<string, unknown>;
+    diff?(doc: Document): void;
+    currentDoc?: keyValue;
+    originalData?: Record<string, unknown>;
+    preparedData?: Record<string, unknown>;
+    modifiedPaths?: string[];
+    changes?: Diff<unknown>[];
+    docPermissions?: keyValue;
+    fieldPermissionAccess?: {
+        readIds?: Set<string>;
+        updateIds?: Set<string>;
+    };
+}
+interface DataMiddlewareContext {
+}
+interface RootQueryEntry {
+    model: string;
+    op: string;
+    id?: string;
+    field?: string;
+    filter?: Filter;
+    data?: unknown;
+    args?: unknown;
+    options?: unknown;
+    order?: number;
+}
+interface SubQueryEntry extends RootQueryEntry {
+    sqOptions?: {
+        path?: string;
+        compact?: boolean;
+    };
+}
+interface Task {
+    type: string;
+    args: unknown;
+    options: Record<string, unknown>;
+}
+interface Request extends express.Request {
+    query: Record<'skip' | 'limit' | 'page' | 'page_size' | 'try_list' | 'skim' | 'include_permissions' | 'include_count' | 'include_extra_headers' | 'returning_all', string>;
+    macl: Core;
+    dacl: DataCore;
+}
+interface ErrorResult<TError = unknown, TQuery = unknown> {
+    success: false;
+    code: Codes.BadRequest | Codes.Unauthorized | Codes.Forbidden | Codes.NotFound;
+    errors?: TError[];
+    query?: TQuery;
+}
+interface SingleResult<T = unknown, TInput = unknown, TQuery = unknown> {
+    success: true;
+    kind: 'single';
+    code: Codes.Success | Codes.Created;
+    data: T;
+    input?: TInput;
+    query?: TQuery;
+    context?: MiddlewareContext;
+}
+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?: MiddlewareContext[];
+}
+type ServiceResult<T = unknown, TError = unknown, TInput = unknown, TQuery = unknown> = SingleResult<T, TInput, TQuery> | ListResult<T, TInput, TQuery> | ErrorResult<TError, TQuery>;
+
+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 PublicUpdateArgs {
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+}
+interface UpdateOneArgs extends Omit<PublicUpdateArgs, 'select' | 'tasks'> {
+    overrides?: {
+        filter?: Filter;
+        populate?: Populate[] | string;
+    };
+}
+interface UpdateByIdArgs extends Omit<UpdateOneArgs, 'overrides'> {
+    overrides?: {
+        populate?: Populate[] | string;
+        idFilter?: Filter;
+    };
+}
+interface UpsertArgs extends UpdateOneArgs {
+}
+interface PublicUpdateOptions {
+    skim?: boolean;
+    returningAll?: boolean;
+    includePermissions?: boolean;
+    populateAccess?: PopulateAccess;
+}
+interface UpdateOneOptions extends Omit<PublicUpdateOptions, 'returningAll'> {
+}
+interface UpdateByIdOptions extends UpdateOneOptions {
+}
+interface UpsertOptions extends UpdateOneOptions {
+}
+
+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 FindArgs {
+    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;
+        select?: Projection;
+        populate?: Populate[] | string;
+    };
+}
+interface FindOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    populateAccess?: PopulateAccess;
+    lean?: boolean;
+}
+interface FindOneArgs {
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    overrides?: {
+        filter?: Filter;
+        select?: Projection;
+        populate?: Populate[] | string;
+    };
+}
+interface FindOneOptions {
+    access?: FindAccess;
+    populateAccess?: PopulateAccess;
+    skim?: boolean;
+    lean?: boolean;
+    includePermissions?: boolean;
+}
+interface FindByIdArgs {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    overrides?: {
+        select?: Projection;
+        populate?: Populate[] | string;
+        idFilter?: Filter;
+    };
+}
+interface FindByIdOptions extends FindOneOptions {
+}
+
+interface ExistsOptions {
+    access?: BaseFilterAccess;
+    includeId?: boolean;
+}
+
+interface DefaultFindOneArgs extends Omit<FindOneArgs, 'overrides'> {
+}
+interface DefaultFindByIdArgs extends Omit<FindByIdArgs, 'overrides'> {
+}
+interface DefaultFindArgs extends Omit<FindArgs, 'overrides'> {
+}
+type MaybePromise<T> = T | Promise<T>;
+type RequestZodSchema = z.ZodTypeAny;
+type GlobalPermissionValue = Record<string, boolean> | string[] | string | null | undefined;
+type BaseFilterHook = (this: express.Request, permissions: Permissions) => MaybePromise<Filter | true | null | undefined>;
+type OverrideFilterHook = (this: express.Request, filter: Filter, permissions: Permissions) => MaybePromise<Filter>;
+type MiddlewareHook<TValue, TContext> = (this: express.Request, value: TValue, permissions: Permissions, context: TContext) => MaybePromise<TValue>;
+type MiddlewareChain<TValue, TContext> = MiddlewareHook<TValue, TContext> | Array<MiddlewareHook<TValue, TContext>>;
+type ValidateRule = boolean | unknown[];
+type ValidateHook = (this: express.Request, allowedData: unknown, permissions: Permissions, context: MiddlewareContext) => MaybePromise<ValidateRule>;
+type DocPermissionsHook = (this: express.Request, doc: unknown, permissions: Permissions, context: MiddlewareContext) => MaybePromise<Record<string, unknown>>;
+type ChangeHook = (this: express.Request, previousValue: unknown, nextValue: unknown, changes: Diff<unknown>[], context: MiddlewareContext) => MaybePromise<void>;
+type ModelMiddleware = MiddlewareChain<unknown, MiddlewareContext>;
+type ModelListMiddleware = MiddlewareChain<unknown[], MiddlewareContext>;
+type DataMiddleware = MiddlewareChain<unknown, DataMiddlewareContext>;
+type DataListMiddleware = MiddlewareChain<unknown[], DataMiddlewareContext>;
+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 {
+    findOneArgs?: DefaultFindOneArgs;
+    findOneOptions?: FindOneOptions;
+    findByIdArgs?: DefaultFindByIdArgs;
+    findByIdOptions?: FindByIdOptions;
+    findArgs?: DefaultFindArgs;
+    findOptions?: FindOptions;
+    createArgs?: CreateArgs;
+    createOptions?: CreateOptions;
+    updateOneArgs?: UpdateOneArgs;
+    updateOneOptions?: UpdateOneOptions;
+    upsertOptions?: UpsertOptions;
+    updateByIdArgs?: UpdateByIdArgs;
+    upsertArgs?: UpsertArgs;
+    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: express.Request, req: express.Request) => MaybePromise<GlobalPermissionValue>;
+    logger?: AccessRouterLogger;
+}
+interface RootRouterOptions {
+    basePath: string;
+    routeGuard?: Validation;
+}
+interface Access {
+    list?: Validation;
+    create?: Validation;
+    read?: Validation;
+    update?: Validation;
+    delete?: Validation;
+    distinct?: Validation;
+    count?: Validation;
+    sub?: Validation | SubRouteGuardOptions;
+}
+interface PermissionSchema {
+    [key: string]: Access;
+}
+interface DocPermissions {
+    list?: Function;
+    create?: Function;
+    read?: Function;
+    update?: Function;
+}
+interface DefaultModelRouterOptions {
+    listHardLimit?: number;
+    documentPermissionField?: string;
+    idParam?: string;
+    identifier?: string | Function;
+    parentPath?: string;
+    queryPath?: string;
+    mutationPath?: string;
+    routeGuard?: Validation | Access;
+    modelPermissionPrefix?: string;
+}
+interface ExtendedDefaultModelRouterOptions extends DefaultModelRouterOptions {
+    'routeGuard.default'?: Validation;
+    'routeGuard.new'?: Validation;
+    'routeGuard.list'?: Validation;
+    'routeGuard.read'?: Validation;
+    'routeGuard.update'?: Validation;
+    'routeGuard.delete'?: Validation;
+    'routeGuard.create'?: Validation;
+    'routeGuard.distinct'?: Validation;
+    'routeGuard.count'?: Validation;
+    'routeGuard.subs'?: SubRouteGuardOptions;
+}
+interface ModelRouterOptions extends DefaultModelRouterOptions {
+    modelName?: string;
+    basePath?: string;
+    permissionSchema?: PermissionSchema;
+    _permissionSchemaKeys?: string[];
+    _globalPermissionKeys?: Record<string, string[]>;
+    _modelPermissionKeys?: Record<string, string[]>;
+    mandatoryFields?: string[];
+    docPermissions?: DocPermissions | DocPermissionsHook;
+    baseFilter?: BaseFilterHook | Record<string, BaseFilterHook>;
+    overrideFilter?: OverrideFilterHook | Record<string, OverrideFilterHook>;
+    decorate?: ModelMiddleware | Record<string, ModelMiddleware>;
+    decorateAll?: ModelListMiddleware | Record<string, ModelListMiddleware>;
+    validate?: ValidateRule | ValidateHook | Record<string, ValidateRule | ValidateHook>;
+    prepare?: ModelMiddleware | Record<string, ModelMiddleware>;
+    transform?: ModelMiddleware | Record<string, ModelMiddleware>;
+    finalize?: ModelMiddleware | Record<string, ModelMiddleware>;
+    change?: Record<string, ChangeHook>;
+    requestSchemas?: RequestSchemas;
+    defaults?: Defaults;
+}
+interface DataRouterOptions {
+    data?: unknown[];
+    listHardLimit?: number;
+    idParam?: string;
+    identifier?: string | Function;
+    parentPath?: string;
+    queryPath?: string;
+    routeGuard?: Validation | Access;
+    dataName?: string;
+    basePath?: string;
+    permissionSchema?: PermissionSchema;
+    baseFilter?: BaseFilterHook | Record<string, BaseFilterHook>;
+    overrideFilter?: OverrideFilterHook | Record<string, OverrideFilterHook>;
+    decorate?: DataMiddleware | Record<string, DataMiddleware>;
+    decorateAll?: DataListMiddleware | Record<string, DataListMiddleware>;
+    requestSchemas?: DataRequestSchemas;
+}
+interface ExtendedModelRouterOptions extends ModelRouterOptions, ExtendedDefaultModelRouterOptions {
+    'mandatoryFields.default'?: string[];
+    'mandatoryFields.list'?: string[];
+    'mandatoryFields.create'?: string[];
+    'mandatoryFields.read'?: string[];
+    'mandatoryFields.update'?: string[];
+    'docPermissions.default'?: DocPermissionsHook;
+    'docPermissions.list'?: DocPermissionsHook;
+    'docPermissions.create'?: DocPermissionsHook;
+    'docPermissions.read'?: DocPermissionsHook;
+    'docPermissions.update'?: DocPermissionsHook;
+    'baseFilter.default'?: BaseFilterHook;
+    'baseFilter.list'?: BaseFilterHook;
+    'baseFilter.read'?: BaseFilterHook;
+    'baseFilter.update'?: BaseFilterHook;
+    'baseFilter.delete'?: BaseFilterHook;
+    'overrideFilter.default'?: OverrideFilterHook;
+    'overrideFilter.list'?: OverrideFilterHook;
+    'overrideFilter.read'?: OverrideFilterHook;
+    'overrideFilter.update'?: OverrideFilterHook;
+    'overrideFilter.delete'?: OverrideFilterHook;
+    'decorate.default'?: ModelMiddleware;
+    'decorate.list'?: ModelMiddleware;
+    'decorate.create'?: ModelMiddleware;
+    'decorate.read'?: ModelMiddleware;
+    'decorate.update'?: ModelMiddleware;
+    'decorateAll.default'?: ModelListMiddleware;
+    'decorateAll.list'?: ModelListMiddleware;
+    'validate.default'?: ValidateRule | ValidateHook;
+    'validate.create'?: ValidateRule | ValidateHook;
+    'validate.update'?: ValidateRule | ValidateHook;
+    'prepare.default'?: ModelMiddleware;
+    'prepare.create'?: ModelMiddleware;
+    'prepare.update'?: ModelMiddleware;
+    'transform.default'?: ModelMiddleware;
+    'transform.update'?: ModelMiddleware;
+    'finalize.default'?: ModelMiddleware;
+    'finalize.create'?: ModelMiddleware;
+    'finalize.update'?: ModelMiddleware;
+    '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;
+    'defaults.findOneOptions'?: FindOneOptions;
+    'defaults.findByIdArgs'?: DefaultFindByIdArgs;
+    'defaults.findByIdOptions'?: FindByIdOptions;
+    'defaults.findArgs'?: DefaultFindArgs;
+    'defaults.findOptions'?: FindOptions;
+    'defaults.createArgs'?: CreateArgs;
+    'defaults.createOptions'?: CreateOptions;
+    'defaults.updateOneArgs'?: UpdateOneArgs;
+    'defaults.updateOneOptions'?: UpdateOneOptions;
+    'defaults.updateByIdArgs'?: UpdateByIdArgs;
+    'defaults.updateByIdOptions'?: UpdateByIdOptions;
+    '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 extends DataRouterOptions {
+    'requestSchemas.advancedList'?: RequestZodSchema;
+    'requestSchemas.advancedReadFilter'?: RequestZodSchema;
+    'requestSchemas.advancedRead'?: RequestZodSchema;
+}
+type SelectAccess = 'list' | 'create' | 'read' | 'update' | string;
+type RouteGuardAccess = 'new' | 'list' | 'read' | 'update' | '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 FinalizeAccess = 'create' | 'update' | string;
+
+interface DistinctArgs {
+    filter?: Filter;
+}
+
+type DataFilter = Filter;
+interface DataFindOneArgs {
+    select?: Projection;
+}
+interface DataFindOneOptions {
+    access?: FindAccess;
+}
+interface DataFindArgs {
+    select?: Projection;
+    sort?: string;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+}
+interface DataFindOptions {
+}
+
+declare function macl(): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+interface GuardModelConditionID {
+    type: string;
+    key: string;
+}
+interface GuardModelCondition {
+    modelName: string;
+    id: string | GuardModelConditionID;
+    condition: string | string[];
+}
+declare function guard(condition: string): any;
+declare function guard(conditions: string[]): any;
+declare function guard(conditionFunc: Function): any;
+declare function guard(modelCondition: GuardModelCondition): any;
+
+type SetTargetOption$1 = {
+    (option: unknown): ModelRouter;
+    (key: string, option: unknown): ModelRouter;
+};
+declare class ModelRouter {
+    readonly modelName: string;
+    readonly router: JsonRouter;
+    readonly model: Model;
+    readonly options: ModelRouterOptions;
+    readonly fullBasePath: string;
+    constructor(modelName: string, initialOptions: ModelRouterOptions);
+    private getRequestSchema;
+    private assertAllowed;
+    private setCollectionRoutes;
+    private setDocumentRoutes;
+    private setSubDocumentRoutes;
+    private logEndpoints;
+    set<K extends keyof ExtendedModelRouterOptions>(keyOrOptions: K | ModelRouterOptions, value?: unknown): this;
+    setOption<K extends keyof ExtendedModelRouterOptions>(key: K, option: ExtendedModelRouterOptions[K]): this;
+    setOptions(options: ModelRouterOptions): this;
+    /**
+     * The maximum limit of the number of documents returned from the `list` operation.
+     */
+    listHardLimit: SetTargetOption$1;
+    /**
+     * The object schema to define the access control policy for each model field.
+     */
+    permissionSchema: SetTargetOption$1;
+    /**
+     * The object field to store the document permissions.
+     */
+    documentPermissionField: SetTargetOption$1;
+    /**
+     * The essential model fields involved in generating document permissions.
+     */
+    mandatoryFields: SetTargetOption$1;
+    /**
+     * The function called in the process of generating document permissions.
+     */
+    docPermissions: SetTargetOption$1;
+    /**
+     * The access control policy for CRUDL endpoints.
+     * @operation `create`, `list`, `read`, `update`, `delete`
+     */
+    routeGuard: SetTargetOption$1;
+    /**
+     * The base filter definitions applied in every query transaction.
+     * @operation `list`, `read`, `update`, `delete`
+     */
+    baseFilter: SetTargetOption$1;
+    /**
+     * The override filter definitions applied in every query transaction.
+     * @operation `list`, `read`, `update`, `delete`
+     */
+    overrideFilter: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function called before a new/update document data is processed in `prepare` hooks. This method is used to validate `write data` and throw an error if not valid.
+     * @operation `create`, `update`
+     */
+    validate: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function called before a new document is created or an existing document is updated. This method is used to process raw data passed into the API endpoints.
+     * @operation `create`, `update`
+     */
+    prepare: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function called before an updated document is saved.
+     * @operation `update`
+     */
+    transform: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function called after a new document is created or an updated document is saved.
+     * @operation `create`, `update`
+     */
+    finalize: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function called after a updated document finalized
+     * @operation `update`
+     */
+    change: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function called before response data is sent. This method is used to process raw data to apply custom logic before sending the result.
+     * @operation `list`, `read`, `create`, `update`
+     */
+    decorate: SetTargetOption$1;
+    /**
+     * Middleware
+     *
+     * The function are called before response data is sent and after `decorate` middleware runs. This method is used to process and filter multiple document objects before sending the result.
+     * @operation `list`
+     */
+    decorateAll: SetTargetOption$1;
+    /**
+     * The document selector definition with the `id` param.
+     * @option `string` | `Function`
+     * @operation `read`, `update`, `delete`
+     */
+    identifier: SetTargetOption$1;
+    /**
+     * The default values used when missing in the operations.
+     */
+    defaults: SetTargetOption$1;
+    get routes(): Router;
+}
+
+declare class RootRouter {
+    router: JsonRouter;
+    basename: string;
+    routeGuard: Validation;
+    constructor(options?: RootRouterOptions);
+    private processResult;
+    private processOp;
+    private groupItemsByOrder;
+    private assertAllowed;
+    private setRoutes;
+    get routes(): Router;
+}
+
+type SetTargetOption = {
+    (option: unknown): DataRouter;
+    (key: string, option: unknown): DataRouter;
+};
+declare class DataRouter {
+    readonly dataName: string;
+    readonly router: JsonRouter;
+    readonly options: DataRouterOptions;
+    readonly fullBasePath: string;
+    constructor(dataName: string, initialOptions: DataRouterOptions);
+    private getRequestSchema;
+    private assertAllowed;
+    private setCollectionRoutes;
+    private setDocumentRoutes;
+    set<K extends keyof DataRouterOptions>(keyOrOptions: K | DataRouterOptions, value?: unknown): this;
+    setOption<K extends keyof DataRouterOptions>(key: K, option: DataRouterOptions[K]): this;
+    setOptions(options: DataRouterOptions): this;
+    data: SetTargetOption;
+    listHardLimit: SetTargetOption;
+    permissionSchema: SetTargetOption;
+    routeGuard: SetTargetOption;
+    baseFilter: SetTargetOption;
+    overrideFilter: SetTargetOption;
+    decorate: SetTargetOption;
+    decorateAll: SetTargetOption;
+    identifier: SetTargetOption;
+    get routes(): Router;
+}
+
+declare const setGlobalOptions: (options: GlobalOptions) => void;
+declare const setGlobalOption: <K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]) => void;
+declare const getGlobalOptions: () => GlobalOptions;
+declare const getGlobalOption: <K extends keyof GlobalOptions>(key: K, defaultValue?: GlobalOptions[K]) => GlobalOptions[K];
+
+declare const setModelOptions: (modelName: string, options: ModelRouterOptions) => void;
+declare const setModelOption: <K extends keyof ExtendedModelRouterOptions>(modelName: string, key: K, value: ExtendedModelRouterOptions[K]) => void;
+declare const getModelOptions: (modelName: string) => ModelRouterOptions;
+declare const getModelOption: <K extends keyof ExtendedModelRouterOptions>(modelName: string, key: K | string, defaultValue?: ExtendedModelRouterOptions[K]) => ExtendedModelRouterOptions[K];
+declare const getModelNames: () => string[];
+declare const getModelJsonSchema: (modelName: string) => Record<string, unknown>;
+
+declare const setDefaultModelOptions: (options: DefaultModelRouterOptions) => void;
+declare const setDefaultModelOption: <K extends keyof ExtendedDefaultModelRouterOptions>(key: K, value: ExtendedDefaultModelRouterOptions[K]) => void;
+declare const getDefaultModelOptions: () => DefaultModelRouterOptions;
+declare const getDefaultModelOption: <K extends keyof ExtendedDefaultModelRouterOptions>(key: K, defaultValue?: ExtendedDefaultModelRouterOptions[K]) => ExtendedDefaultModelRouterOptions[K];
+
+interface Options {
+    virtualPermissionField?: string;
+    modelName: string;
+}
+declare function permissionsPlugin(schema: any, options: Options): void;
+
+declare const MIDDLEWARE: unique symbol;
+declare const DATA_MIDDLEWARE: unique symbol;
+declare const CORE: unique symbol;
+declare const PERMISSIONS: unique symbol;
+declare const PERMISSION_KEYS: unique symbol;
+
+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 = {
+    query?: Filter | unknown[];
+    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 = {
+    query?: Filter | unknown[];
+    filter?: Filter | unknown[];
+    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 = {
+    query?: Filter | unknown[];
+    filter?: Filter | unknown[];
+};
+type SubListBody = {
+    filter?: Filter;
+    fields?: string[];
+};
+type SubReadBody = {
+    fields?: string[];
+    populate?: SubPopulate | SubPopulate[] | string | string[];
+};
+declare const rootQuerySchema: z.ZodArray<z.ZodObject<{
+    model: z.ZodString;
+    op: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    field: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    args: z.ZodOptional<z.ZodUnknown>;
+    options: z.ZodOptional<z.ZodUnknown>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>>;
+declare const listBodySchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<1>, z.ZodLiteral<"asc">, z.ZodLiteral<"ascending">, z.ZodLiteral<"desc">, z.ZodLiteral<"descending">]>>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<1>, z.ZodLiteral<"asc">, z.ZodLiteral<"ascending">, z.ZodLiteral<"desc">, z.ZodLiteral<"descending">]>], null>>, z.ZodNull]>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>;
+    include: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        model: z.ZodString;
+        op: z.ZodEnum<{
+            read: "read";
+            list: "list";
+            count: "count";
+        }>;
+        path: z.ZodString;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        localField: z.ZodString;
+        foreignField: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodArray<z.ZodObject<{
+        model: z.ZodString;
+        op: z.ZodEnum<{
+            read: "read";
+            list: "list";
+            count: "count";
+        }>;
+        path: z.ZodString;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        localField: z.ZodString;
+        foreignField: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>]>>;
+    tasks: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>]>>;
+    skip: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    limit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    page: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    pageSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        skim: z.ZodOptional<z.ZodBoolean>;
+        includePermissions: z.ZodOptional<z.ZodBoolean>;
+        includeCount: z.ZodOptional<z.ZodBoolean>;
+        includeExtraHeaders: z.ZodOptional<z.ZodBoolean>;
+        populateAccess: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const dataListBodySchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<1>, z.ZodLiteral<"asc">, z.ZodLiteral<"ascending">, z.ZodLiteral<"desc">, z.ZodLiteral<"descending">]>>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<1>, z.ZodLiteral<"asc">, z.ZodLiteral<"ascending">, z.ZodLiteral<"desc">, z.ZodLiteral<"descending">]>], null>>, z.ZodNull]>>;
+    skip: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    limit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    page: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    pageSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        includeCount: z.ZodOptional<z.ZodBoolean>;
+        includeExtraHeaders: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const countBodySchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    access: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+declare const readFilterBodySchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<1>, z.ZodLiteral<"asc">, z.ZodLiteral<"ascending">, z.ZodLiteral<"desc">, z.ZodLiteral<"descending">]>>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<1>, z.ZodLiteral<"asc">, z.ZodLiteral<"ascending">, z.ZodLiteral<"desc">, z.ZodLiteral<"descending">]>], null>>, z.ZodNull]>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>;
+    include: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        model: z.ZodString;
+        op: z.ZodEnum<{
+            read: "read";
+            list: "list";
+            count: "count";
+        }>;
+        path: z.ZodString;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        localField: z.ZodString;
+        foreignField: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodArray<z.ZodObject<{
+        model: z.ZodString;
+        op: z.ZodEnum<{
+            read: "read";
+            list: "list";
+            count: "count";
+        }>;
+        path: z.ZodString;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        localField: z.ZodString;
+        foreignField: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>]>>;
+    tasks: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        skim: z.ZodOptional<z.ZodBoolean>;
+        includePermissions: z.ZodOptional<z.ZodBoolean>;
+        tryList: z.ZodOptional<z.ZodBoolean>;
+        populateAccess: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const dataReadFilterBodySchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    options: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$loose>;
+declare const readByIdBodySchema: z.ZodObject<{
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>;
+    include: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        model: z.ZodString;
+        op: z.ZodEnum<{
+            read: "read";
+            list: "list";
+            count: "count";
+        }>;
+        path: z.ZodString;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        localField: z.ZodString;
+        foreignField: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodArray<z.ZodObject<{
+        model: z.ZodString;
+        op: z.ZodEnum<{
+            read: "read";
+            list: "list";
+            count: "count";
+        }>;
+        path: z.ZodString;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        localField: z.ZodString;
+        foreignField: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>]>>;
+    tasks: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        skim: z.ZodOptional<z.ZodBoolean>;
+        includePermissions: z.ZodOptional<z.ZodBoolean>;
+        tryList: z.ZodOptional<z.ZodBoolean>;
+        populateAccess: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const dataReadByIdBodySchema: z.ZodObject<{
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    options: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$loose>;
+declare const advancedCreateBodySchema: z.ZodObject<{
+    data: z.ZodUnknown;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>;
+    tasks: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        includePermissions: z.ZodOptional<z.ZodBoolean>;
+        populateAccess: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const createBodySchema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+declare const updateBodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+declare const advancedUpdateBodySchema: z.ZodObject<{
+    data: z.ZodUnknown;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>;
+    tasks: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        returningAll: z.ZodOptional<z.ZodBoolean>;
+        includePermissions: z.ZodOptional<z.ZodBoolean>;
+        populateAccess: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const upsertBodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+declare const advancedUpsertBodySchema: z.ZodObject<{
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+        match: z.ZodOptional<z.ZodUnknown>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            list: "list";
+        }>>;
+    }, z.core.$loose>]>>;
+    tasks: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        args: z.ZodUnknown;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>]>>;
+    options: z.ZodOptional<z.ZodObject<{
+        returningAll: z.ZodOptional<z.ZodBoolean>;
+        includePermissions: z.ZodOptional<z.ZodBoolean>;
+        populateAccess: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const distinctBodySchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>>;
+}, z.core.$loose>;
+declare const subListBodySchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+declare const subMutationBodySchema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+declare const subReadBodySchema: z.ZodObject<{
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    populate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    }, z.core.$loose>]>>, z.ZodObject<{
+        path: z.ZodString;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>]>>;
+    }, z.core.$loose>]>>;
+}, z.core.$loose>;
+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?: z.ZodTypeAny): z.output<TSchema>;
+declare function parseNestedBodyWithSchema(schema: z.ZodTypeAny, value: unknown, nestedKey: string, userSchema?: z.ZodTypeAny): Record<string, unknown>;
+declare const requestSchemas: {
+    listQuery: z.ZodObject<{
+        skip: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodString>;
+        page_size: z.ZodOptional<z.ZodString>;
+        skim: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+        include_permissions: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+        include_count: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+        include_extra_headers: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+    }, z.core.$loose>;
+    createQuery: z.ZodObject<{
+        include_permissions: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+    }, z.core.$loose>;
+    readQuery: z.ZodObject<{
+        include_permissions: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+        try_list: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+    }, z.core.$loose>;
+    updateQuery: z.ZodObject<{
+        returning_all: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+    }, z.core.$loose>;
+    upsertQuery: z.ZodObject<{
+        returning_all: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+        include_permissions: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+    }, z.core.$loose>;
+};
+
+type CreateRouter = {
+    (modelName: string, options: ModelRouterOptions): ModelRouter;
+    (options: RootRouterOptions): RootRouter;
+};
+type CreateDataRouter = {
+    (dataName: string, options: DataRouterOptions): DataRouter;
+};
+type WttSet = {
+    <K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]): void;
+    (options: {
+        [K in keyof GlobalOptions]: GlobalOptions[K];
+    }): void;
+};
+interface Wtt {
+    createRouter: CreateRouter;
+    createDataRouter: CreateDataRouter;
+    set: WttSet;
+    setGlobalOptions: typeof setGlobalOptions;
+    setGlobalOption: typeof setGlobalOption;
+    getGlobalOptions: typeof getGlobalOptions;
+    getGlobalOption: typeof getGlobalOption;
+    setModelOptions: typeof setModelOptions;
+    setModelOption: typeof setModelOption;
+    getModelOptions: typeof getModelOptions;
+    getModelOption: typeof getModelOption;
+    getModelNames: typeof getModelNames;
+    getModelJsonSchema: typeof getModelJsonSchema;
+    setDefaultModelOptions: typeof setDefaultModelOptions;
+    setDefaultModelOption: typeof setDefaultModelOption;
+    getDefaultModelOptions: typeof getDefaultModelOptions;
+    getDefaultModelOption: typeof getDefaultModelOption;
+    RootRouter: typeof RootRouter;
+    ModelRouter: typeof ModelRouter;
+    DataRouter: typeof DataRouter;
+}
+declare const wtt: typeof macl & Wtt;
+
+export { type AccessRouterLogger, type AdvancedCreateBody, type AdvancedListBody, type AdvancedReadBody, type AdvancedReadFilterBody, type AdvancedUpdateBody, type AdvancedUpsertBody, type BaseFilterAccess, CORE, Codes, type CountBody, type CreateArgs, type CreateOptions, type CreateQueryInput, CustomHeaders, DATA_MIDDLEWARE, type DataFilter, type DataFindArgs, type DataFindOneArgs, type DataFindOneOptions, type DataFindOptions, type DataMiddlewareContext, type DataRequestSchemas, type DataRouterOptions, type DecorateAccess, type DecorateAllAccess, type DefaultModelRouterOptions, type Defaults, type DistinctArgs, type DistinctBody, type DocPermissionsAccess, type ErrorResult, type ExistsOptions, type ExtendedDataRouterOptions, type ExtendedDefaultModelRouterOptions, type ExtendedModelRouterOptions, type Filter, FilterOperator, type FinalizeAccess, type FindAccess, type FindArgs, type FindByIdArgs, type FindByIdOptions, type FindOneArgs, type FindOneOptions, type FindOptions, type GlobalOptions, type Include, type KeyValueProjection, type ListQueryInput, type ListResult, MIDDLEWARE, type MiddlewareContext, ModelRouter, type ModelRouterOptions, PERMISSIONS, PERMISSION_KEYS, type Permissions, type Populate, type PopulateAccess, type PrepareAccess, type Projection, type PublicCreateArgs, type PublicCreateOptions, type PublicListArgs, type PublicListOptions, type PublicReadArgs, type PublicReadOptions, type PublicUpdateArgs, type PublicUpdateOptions, type ReadQueryInput, type Request, type RequestSchemas, type RootQueryEntry, RootRouter, type RootRouterOptions, type RouteGuardAccess, type SelectAccess, type ServiceResult, type SingleResult, type Sort, type SortOrder, StatusCodes, type SubListBody, type SubPopulate, type SubQueryEntry, type SubReadBody, type Task, type TransformAccess, type UpdateByIdArgs, type UpdateByIdOptions, type UpdateOneArgs, type UpdateOneOptions, type UpdateQueryInput, type UpsertArgs, type UpsertOptions, type UpsertQueryInput, type ValidateAccess, type Validation, advancedCreateBodySchema, advancedUpdateBodySchema, advancedUpsertBodySchema, countBodySchema, createBodySchema, dataListBodySchema, dataReadByIdBodySchema, dataReadFilterBodySchema, wtt as default, distinctBodySchema, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, listBodySchema, parseBody, parseBodyWithSchema, parseNestedBodyWithSchema, parsePathParam, parseQuery, permissionsPlugin, readByIdBodySchema, readFilterBodySchema, requestSchemas, rootQuerySchema, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions, subListBodySchema, subMutationBodySchema, subReadBodySchema, updateBodySchema, upsertBodySchema };