@web-ts-toolkit/access-router 0.32.0 → 0.34.0

package/parsers-D9B9dS0p.d.ts

@@ -0,0 +1,1702 @@
+import { z } from 'zod';
+import mongoose from 'mongoose';
+import express from 'express';
+
+interface BooleanObject {
+    [key: string]: boolean;
+}
+interface AccessRouterPermissionMap {
+}
+type AccessRouterPermissionKey = Extract<keyof AccessRouterPermissionMap, string>;
+type PermissionName = AccessRouterPermissionKey | (string & {});
+declare class Permission {
+    private readonly permissions;
+    private readonly permissionKeys;
+    constructor(permissions: BooleanObject);
+    get keys(): readonly string[];
+    private normalizePermissionArgs;
+    hasKey(permission: PermissionName): boolean;
+    has(permission: PermissionName): boolean;
+    hasAny(permissionOrPermissions: PermissionName | readonly PermissionName[], ...permissions: PermissionName[]): boolean;
+    hasAll(permissionOrPermissions: PermissionName | readonly PermissionName[], ...permissions: PermissionName[]): boolean;
+}
+
+type Permissions = Permission;
+type AccessRouterPermissions = Permission;
+
+type OpenApiMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type OpenApiSchema = Record<string, unknown>;
+type OpenApiSchemaSource = unknown;
+type OpenApiParameter = {
+    name: string;
+    in: 'path' | 'query';
+    required?: boolean;
+    description?: string;
+    schema?: OpenApiSchema;
+};
+type OpenApiResponse = {
+    description: string;
+    content?: Record<string, {
+        schema: OpenApiSchema;
+    }>;
+};
+type OpenApiResponses = Record<string, OpenApiResponse>;
+type OpenApiRouteDescriptor = {
+    method: OpenApiMethod;
+    path: string;
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    acl?: string;
+    deprecated?: boolean;
+    query?: OpenApiSchemaSource;
+    body?: OpenApiSchemaSource;
+    pathParams?: Record<string, OpenApiSchemaSource>;
+    responses?: OpenApiResponses;
+    /**
+     * When true, replaces an existing registration with the same method/path
+     * even when the descriptors differ. When false (default), conflicting
+     * registrations throw at registration time so consumers can detect
+     * accidental route shadowing.
+     */
+    allowReplace?: boolean;
+    /**
+     * When true, this exact descriptor is idempotent and registering the same
+     * method/path with an equivalent descriptor again is silently accepted.
+     * Differing re-registrations still throw unless {@link allowReplace} is set.
+     * Additionally, an idempotent descriptor may share its operationId with
+     * another idempotent descriptor mounted at a different path on the same
+     * registry, so reserved operations (e.g. the root batch route) can be
+     * exposed from multiple base paths without triggering strict-mode
+     * duplicate-operationId rejection.
+     */
+    idempotent?: boolean;
+};
+type OpenApiRegistryOptions = {
+    /**
+     * Throw when the same method/path is registered twice with differing
+     * descriptors, instead of silently replacing. Default: true (strict).
+     * The {@link AccessRuntime} registry is constructed in strict mode by
+     * default; construct {@link OpenApiRegistry} directly with
+     * `rejectConflicts: false` for legacy replacement semantics.
+     */
+    rejectConflicts?: boolean;
+    /**
+     * Throw when the same operationId is registered more than once, including
+     * when {@link OpenApiRouteDescriptor.allowReplace} is set. Default: true.
+     */
+    rejectDuplicateOperationIds?: boolean;
+};
+type OpenApiDocumentOptions = {
+    title: string;
+    version: string;
+    description?: string;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+};
+type OpenApiRouterOptions = Partial<OpenApiDocumentOptions> & {
+    jsonPath?: string;
+    docsPath?: string | false;
+    swaggerUiCssUrl?: string;
+    swaggerUiBundleUrl?: string;
+};
+
+declare class AccessRuntime {
+    constructor();
+    private readonly globalOptions;
+    private readonly defaultModelOptions;
+    private readonly modelOptions;
+    private readonly modelJsonSchemas;
+    private readonly dataOptions;
+    private readonly modelRefs;
+    private readonly modelSubs;
+    private readonly modelAtts;
+    private readonly modelInstances;
+    private readonly openApiRegistry;
+    registerModelInstance(modelName: string, model: mongoose.Model<unknown>): void;
+    hasModelInstance(modelName: string): boolean;
+    getModelInstance(modelName: string): mongoose.Model<unknown> | null;
+    registerOpenApiRoute(route: OpenApiRouteDescriptor): void;
+    /**
+     * Enable strict OpenAPI collision detection for the remainder of this
+     * runtime's lifetime. After this call, conflicting method/path
+     * registrations and duplicate operationIds throw {@link OpenApiCollisionError}
+     * instead of silently replacing. Existing already-registered routes are
+     * not retroactively re-validated.
+     */
+    enableOpenApiCollisionDetection(): void;
+    getOpenApiRoutes(): OpenApiRouteDescriptor[];
+    clearOpenApiRoutes(): void;
+    getOpenApiSpec(info: OpenApiDocumentOptions): {
+        openapi: string;
+        info: Omit<OpenApiDocumentOptions, "servers">;
+        servers?: OpenApiDocumentOptions["servers"];
+        paths: Record<string, Record<string, {
+            [key: `x-${string}`]: unknown;
+            operationId?: string;
+            summary?: string;
+            description?: string;
+            tags?: string[];
+            deprecated?: boolean;
+            parameters?: OpenApiParameter[];
+            requestBody?: {
+                required?: boolean;
+                content: Record<string, {
+                    schema: OpenApiSchema;
+                }>;
+            };
+            responses: OpenApiResponses;
+        }>>;
+    };
+    setGlobalOptions(options: GlobalOptions): void;
+    setGlobalOption<K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]): void;
+    getGlobalOptions(): GlobalOptions;
+    getGlobalOption<K extends keyof GlobalOptions>(key: K, defaultValue?: GlobalOptions[K]): GlobalOptions[K];
+    setDefaultModelOptions(options: DefaultModelRouterOptions): void;
+    setDefaultModelOption<K extends keyof ExtendedDefaultModelRouterOptions>(key: K, value: ExtendedDefaultModelRouterOptions[K]): void;
+    getDefaultModelOptions(): DefaultModelRouterOptions<unknown>;
+    getDefaultModelOption<K extends keyof ExtendedDefaultModelRouterOptions>(key: K, defaultValue?: ExtendedDefaultModelRouterOptions[K]): ExtendedDefaultModelRouterOptions<unknown>[K];
+    private createModelOptions;
+    private getOrCreateModelOptions;
+    setModelOptions<TModel = unknown>(modelName: string, options: ModelRouterOptions<TModel>): void;
+    setModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K, value: ExtendedModelRouterOptions<TModel>[K]): void;
+    getModelOptions<TModel = unknown>(modelName: string): ModelRouterOptions<TModel>;
+    getModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string, defaultValue?: ExtendedModelRouterOptions<TModel>[K]): ExtendedModelRouterOptions<TModel>[K];
+    getExactModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string): ExtendedModelRouterOptions<TModel>[K];
+    getModelNames(): string[];
+    hasModel(modelName: string): boolean;
+    getModelJsonSchema(modelName: string): Record<string, unknown>;
+    private createDataOptions;
+    private getOrCreateDataOptions;
+    setDataOptions<TData = unknown>(dataName: string, options: DataRouterOptions<TData>): void;
+    setDataOption<K extends keyof DataRouterOptions<TData>, TData = unknown>(dataName: string, key: K, value: DataRouterOptions<TData>[K]): void;
+    getDataOptions<TData = unknown>(dataName: string): DataRouterOptions<TData>;
+    getDataOption<K extends keyof DataRouterOptions<TData>, TData = unknown>(dataName: string, key: K | string, defaultValue?: DataRouterOptions<TData>[K]): DataRouterOptions<TData>[K];
+    getExactDataOption<K extends keyof ExtendedDataRouterOptions<TData>, TData = unknown>(dataName: string, key: K | string): ExtendedDataRouterOptions<TData>[K];
+    getDataNames(): string[];
+    ensureModelMeta(modelName: string): void;
+    getModelRef(modelName: string, refPath: string): string | null;
+    getModelSub(modelName: string): string[];
+    getModelAtt(modelName: string): string[];
+}
+declare const defaultRuntime: AccessRuntime;
+
+interface FindProps {
+    filter: Filter;
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    limit?: string | number;
+    hardLimit?: number;
+    skip?: string | number;
+    lean?: boolean;
+}
+interface FindOneProps {
+    filter: Filter;
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    lean?: boolean;
+}
+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>;
+    runtime: AccessRuntime | null;
+    constructor(modelName: string, runtime?: AccessRuntime);
+    new(): any;
+    create(data: unknown): Promise<any>;
+    find({ filter, select, sort, populate, limit, hardLimit, skip, lean }: FindProps): mongoose.Query<any[], any, {}, any, "find", {}>;
+    validateSort(sort: SortType, logError?: (msg: string, ...args: unknown[]) => void): boolean;
+    findOne({ filter, select, sort, populate, lean }: FindOneProps): mongoose.Query<any, any, {}, any, "findOne", {}>;
+    exists(filter: Filter): ReturnType<typeof Model.prototype.findOne> | null;
+    countDocuments(filter?: {}): mongoose.Query<number, any, {}, any, "countDocuments", {}>;
+    distinct(field: string, conditions?: {}): mongoose.Query<any[], any, {}, any, "distinct", {}>;
+}
+
+declare class Service<TModel = unknown> extends Base<TModel> {
+    protected model: Model;
+    protected options: ModelRouterOptions<TModel>;
+    defaults: Defaults<TModel>;
+    protected baseFields: string[];
+    protected baseFieldsExt: string[];
+    findRawParentDoc(args: {
+        filter: Filter<TModel>;
+        select: string;
+        populate: unknown;
+        lean: boolean;
+    }): ReturnType<Model['findOne']>;
+    private asServiceHookContext;
+    private beginOp;
+    private completeOp;
+    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?: (doc: unknown, context?: ModelHookContext) => unknown): Promise<ListResult<TModel> | ErrorResult>;
+    create(data: Record<string, unknown> | Record<string, unknown>[], args?: CreateArgs, options?: CreateOptions, decorate?: (doc: unknown, context?: ModelHookContext) => unknown): Promise<ListResult<TModel> | ErrorResult>;
+    private formatBulkValidationIssue;
+    new(args?: {
+        select?: string[];
+    }, options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+    }): Promise<SingleResult<TModel>>;
+    updateOne(filter: Filter<TModel>, data: Record<string, unknown>, args?: UpdateOneArgs<TModel>, options?: UpdateOneOptions, decorate?: (doc: unknown, context?: ModelHookContext) => unknown): Promise<SingleResult<TModel> | ErrorResult>;
+    updateById(id: string, data: Record<string, unknown>, args?: UpdateByIdArgs<TModel>, options?: UpdateByIdOptions, decorate?: (doc: unknown, context?: ModelHookContext) => unknown): Promise<SingleResult<TModel> | ErrorResult>;
+    upsert(filter: Filter<TModel>, data: Record<string, unknown>, args?: UpsertArgs<TModel>, options?: UpsertOptions, decorate?: (doc: unknown, context?: ModelHookContext) => unknown): 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>;
+    protected isValidDistinctFieldName(field: unknown): boolean;
+    protected authorizeDistinctField(field: string): Promise<ErrorResult | null>;
+    distinct(field: string, args?: DistinctArgs<TModel>): Promise<ListResult<unknown> | ErrorResult>;
+    count(filter: Filter<TModel>, access?: BaseFilterAccess): Promise<SingleResult<number> | ErrorResult>;
+    getDocPermissions(doc: unknown): Record<string, unknown>;
+    private resolveFindOneArgs;
+    private resolveFindOneOptions;
+    private resolveFindByIdArgs;
+    private resolveFindByIdOptions;
+    private resolveFindArgs;
+    private resolveFindOptions;
+    private resolveCreateArgs;
+    private resolveCreateOptions;
+    private resolveUpdateOneArgs;
+    private resolveUpdateOneOptions;
+    private resolveUpdateByIdArgs;
+    private resolveUpdateByIdOptions;
+    private resolveUpsertArgs;
+    private resolveUpsertOptions;
+    private resolveExistsOptions;
+    private getFieldPermissionAccess;
+    private getAccessibleIdSet;
+    listSub(id: SubdocumentId, sub: SubdocumentName, options?: SubdocumentListOptions<TModel>): Promise<ListResult | ErrorResult>;
+    readSub(id: SubdocumentId, sub: SubdocumentName, subId: SubdocumentId, options?: SubdocumentReadOptions): Promise<SingleResult | ErrorResult>;
+    updateSub(id: SubdocumentId, sub: SubdocumentName, subId: SubdocumentId, data: Record<string, unknown>): Promise<SingleResult | ErrorResult>;
+    bulkUpdateSub(id: SubdocumentId, sub: SubdocumentName, data: SubdocumentBulkUpdateInput | Record<string, unknown>): Promise<ListResult | ErrorResult>;
+    createSub(id: SubdocumentId, sub: SubdocumentName, data: SubdocumentCreateInput, options?: SubdocumentCreateOptions): Promise<ListResult | ErrorResult>;
+    deleteSub(id: SubdocumentId, sub: SubdocumentName, subId: SubdocumentId): Promise<SingleResult | ErrorResult>;
+    getParentDoc(id: SubdocumentId, sub: SubdocumentName, args?: SubdocumentParentArgs, options?: SubdocumentParentOptions): 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: unknown, args?: Omit<PublicCreateArgs, 'select' | 'populate'> & {
+        select?: TSelect;
+        populate?: TPopulate;
+    }, options?: PublicCreateOptions): Promise<ListResult<SelectedPopulatedPublicOutput<TModel, TSelect, TPopulate>> | ErrorResult>;
+    _new(args?: {
+        select?: string[];
+    }, options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+    }): 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: Record<string, unknown>, 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;
+}
+
+type ValidationError = {
+    detail: string;
+    pointer?: string;
+    parameter?: string;
+};
+type RequestSchemaIssue = {
+    message: string;
+    path?: Array<string | number>;
+};
+type RequestSchemaSuccess<T = unknown> = {
+    success: true;
+    data: T;
+};
+type RequestSchemaFailure = {
+    success: false;
+    issues: RequestSchemaIssue[];
+};
+type RequestSchemaResult<T = unknown> = RequestSchemaSuccess<T> | RequestSchemaFailure;
+type RequestSchemaValidator<T = unknown> = (value: unknown) => RequestSchemaResult<T> | Promise<RequestSchemaResult<T>>;
+type RequestSchemaAdapter<T = unknown> = {
+    validate: RequestSchemaValidator<T>;
+    openapi?: Record<string, unknown>;
+};
+type RequestSchemaOptions = {
+    openapi?: Record<string, unknown>;
+};
+type StandardSchemaPathSegment = {
+    key: PropertyKey;
+};
+type StandardSchemaIssue = {
+    message: string;
+    path?: ReadonlyArray<PropertyKey | StandardSchemaPathSegment>;
+};
+type StandardSchemaSuccess<T = unknown> = {
+    value: T;
+    issues?: undefined;
+};
+type StandardSchemaFailure = {
+    issues: ReadonlyArray<StandardSchemaIssue>;
+};
+type StandardSchemaResult<T = unknown> = StandardSchemaSuccess<T> | StandardSchemaFailure;
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown, options?: {
+            readonly libraryOptions?: Record<string, unknown> | undefined;
+        }) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+    };
+};
+type StandardSchemaInferOutput<TSchema extends StandardSchemaV1> = NonNullable<TSchema['~standard']['types']>['output'];
+type RequestSchemaLike<T = unknown> = RequestSchemaValidator<T> | RequestSchemaAdapter<T> | StandardSchemaV1;
+type YupValidationErrorLike = {
+    message: string;
+    path?: string;
+    inner?: ReadonlyArray<YupValidationErrorLike>;
+};
+type YupSchemaLike<T = unknown> = {
+    validate: (value: unknown, options?: {
+        abortEarly?: boolean;
+        stripUnknown?: boolean;
+    }) => Promise<T> | T;
+};
+type JoiValidationErrorDetailLike = {
+    message: string;
+    path?: ReadonlyArray<string | number>;
+};
+type JoiSchemaLike<T = unknown> = {
+    validate: (value: unknown, options?: {
+        abortEarly?: boolean;
+        stripUnknown?: boolean;
+    }) => {
+        value: T;
+        error?: {
+            details?: ReadonlyArray<JoiValidationErrorDetailLike>;
+        };
+    } | Promise<{
+        value: T;
+        error?: {
+            details?: ReadonlyArray<JoiValidationErrorDetailLike>;
+        };
+    }>;
+};
+type AjvErrorObjectLike = {
+    message?: string;
+    instancePath?: string;
+    schemaPath?: string;
+    params?: {
+        missingProperty?: string;
+    };
+};
+type AjvValidatorLike<T = unknown> = {
+    (value: unknown): boolean | Promise<boolean>;
+    errors?: ReadonlyArray<AjvErrorObjectLike> | null;
+};
+type ValibotPathItemLike = {
+    key?: unknown;
+};
+type ValibotIssueLike = {
+    message: string;
+    path?: ReadonlyArray<ValibotPathItemLike>;
+};
+type ValibotSafeParseResult<T = unknown> = {
+    success: true;
+    output: T;
+    issues?: undefined;
+} | {
+    success: false;
+    output?: undefined;
+    issues: ReadonlyArray<ValibotIssueLike>;
+};
+type ValibotSafeParseLike = <TSchema, TOutput = unknown>(schema: TSchema, value: unknown, config?: {
+    abortEarly?: boolean;
+}) => ValibotSafeParseResult<TOutput> | Promise<ValibotSafeParseResult<TOutput>>;
+type ArkTypeProblemLike = {
+    path?: ReadonlyArray<string | number>;
+    message?: string;
+    problem?: string;
+};
+type ArkTypeErrorsLike = ReadonlyArray<ArkTypeProblemLike> & {
+    summary?: string;
+};
+type ArkTypeLike<T = unknown> = {
+    (value: unknown): T | ArkTypeErrorsLike;
+    errors?: unknown;
+};
+type IoTsContextEntryLike = {
+    key: string;
+};
+type IoTsDecodeErrorLike = {
+    message?: string;
+    context: ReadonlyArray<IoTsContextEntryLike>;
+};
+type IoTsDecoderLike<T = unknown> = {
+    decode: (value: unknown) => {
+        _tag: 'Left';
+        left: ReadonlyArray<IoTsDecodeErrorLike>;
+    } | {
+        _tag: 'Right';
+        right: T;
+    };
+};
+type SuperstructFailureLike = {
+    message?: string;
+    path?: ReadonlyArray<string | number>;
+    key?: string | number;
+    branch?: ReadonlyArray<unknown>;
+    failures?: () => ReadonlyArray<SuperstructFailureLike>;
+};
+type SuperstructValidateLike = <TStruct, TOutput = unknown>(value: unknown, struct: TStruct) => readonly [failure: SuperstructFailureLike, value: undefined] | readonly [failure: undefined, value: TOutput] | Promise<readonly [failure: SuperstructFailureLike, value: undefined] | readonly [failure: undefined, value: TOutput]>;
+type VineValidationMessageLike = {
+    field: string;
+    message: string;
+    index?: number;
+};
+type VineValidationErrorLike = {
+    messages: ReadonlyArray<VineValidationMessageLike>;
+};
+type VineValidatorLike<T = unknown> = {
+    validate: (value: unknown) => Promise<T> | T;
+};
+type ListQueryInput = {
+    skip?: string;
+    limit?: string;
+    page?: string;
+    page_size?: string;
+    skim?: 'true' | 'false';
+    include_permissions?: 'true' | 'false';
+    include_count?: 'true' | 'false';
+    include_extra_headers?: 'true' | 'false';
+};
+type CreateQueryInput = {
+    include_permissions?: 'true' | 'false';
+};
+type ReadQueryInput = {
+    include_permissions?: 'true' | 'false';
+    try_list?: 'true' | 'false';
+};
+type UpdateQueryInput = {
+    returning_all?: 'true' | 'false';
+};
+type UpsertQueryInput = {
+    returning_all?: 'true' | 'false';
+    include_permissions?: 'true' | 'false';
+};
+type AdvancedListBody = {
+    filter?: Filter | unknown[];
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        includeCount?: boolean;
+        includeExtraHeaders?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type CountBody = {
+    filter?: Filter | unknown[];
+};
+type AdvancedReadFilterBody = {
+    filter?: Filter | unknown[];
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        tryList?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedReadBody = {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        tryList?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedCreateBody = {
+    data: unknown;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedUpdateBody = {
+    data: unknown;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        returningAll?: boolean;
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedUpsertBody = {
+    data: Record<string, unknown>;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        returningAll?: boolean;
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type DistinctBody = {
+    filter?: Filter | unknown[];
+};
+type SubListBody = {
+    filter?: Filter;
+    select?: string[];
+};
+type SubReadBody = {
+    select?: string[];
+    populate?: SubPopulate | SubPopulate[] | string | string[];
+};
+
+interface RequestComplexityOptions {
+    maxDepth?: number;
+    maxNodes?: number;
+    maxLogicalClauses?: number;
+    maxInValues?: number;
+    maxBulkItems?: number;
+    maxIncludeCount?: number;
+    maxSubQueryCount?: number;
+    maxBulkConcurrency?: number;
+}
+
+type CrossResourceModelOperation = 'list' | 'read' | 'count';
+declare class Base<TModel = unknown> {
+    protected req: ModelRequest;
+    protected modelName: string;
+    constructor(req: ModelRequest, modelName: string);
+    decorate<T>(doc: T, access: DecorateAccess, context: ModelHookContext): Promise<T>;
+    decorateAll<T>(docs: T[], access: DecorateAllAccess, context: ModelHookContext): Promise<T[]>;
+    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    genDocPermissions(doc: unknown, access: DocPermissionsAccess, context: ModelHookContext): Promise<Record<string, unknown>>;
+    genFilter(access?: BaseFilterAccess, filter?: Filter<TModel>): Promise<Filter<TModel>>;
+    getIdentifier(): string | null;
+    genIDFilter(id: string): Promise<Filter<TModel>>;
+    genPopulate(access?: SelectAccess, populate?: Populate | Populate[] | string | null): Promise<Populate[]>;
+    genSelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    genQuerySelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    addEmptyPermissions<T>(doc: T): T;
+    addDocPermissions<T>(doc: T, access: DocPermissionsAccess, context: ModelHookContext): Promise<T>;
+    addFieldPermissions<T extends {
+        _id?: unknown;
+    }>(doc: T, access: DocPermissionsAccess, context: ModelHookContext): Promise<T>;
+    pickAllowedFields<T>(doc: T, access: SelectAccess, baseFields?: string[]): Promise<T>;
+    trimOutputFields<T>(doc: T, access: SelectAccess, baseFields?: string[]): Promise<T>;
+    prepare<T>(allowedData: T, access: PrepareAccess, context: ModelHookContext): Promise<T>;
+    runTasks<T extends object>(docObject: T, tasks: Task | Task[]): T;
+    transform<T>(doc: T, access: TransformAccess, context: ModelHookContext): Promise<T>;
+    afterPersist<T>(doc: T, access: AfterPersistAccess, context: ModelHookContext): Promise<T>;
+    changes(doc: Record<string, unknown>, context: ModelHookContext): Promise<void>;
+    beforeDelete<T>(doc: T, context: ModelHookContext): Promise<void>;
+    afterDelete<T>(doc: T, context: ModelHookContext): Promise<void>;
+    validate(allowedData: unknown, access: ValidateAccess, context: ModelHookContext): Promise<boolean | unknown[]>;
+    checkIfModelPermissionExists(accesses: DocPermissionsAccess[]): boolean;
+    protected validateClientFilter(filter: Filter | null | undefined): string[];
+    getRequestComplexity(): Required<RequestComplexityOptions>;
+    protected getClientRequestErrorResult(error: unknown): ErrorResult | null;
+    protected throwClientRequestError(code: ErrorResult['code'], detail: string): never;
+    protected getAuthorizedTargetService(modelName: string, op: CrossResourceModelOperation): Promise<PublicService<unknown>>;
+    protected processInclude(include: Include | Include[]): {
+        includes: Include[];
+        includeLocalFields: string[];
+        includePaths: string[];
+    };
+    protected includeDocs<TDoc>(docs: TDoc | TDoc[], include: Include | Include[]): Promise<TDoc | TDoc[]>;
+    private includeDocsList;
+    private includeDocsCount;
+    protected parseClientData<TValue>(filter: TValue): Promise<TValue>;
+    private handleSubQuery;
+    private handleDate;
+}
+
+declare class DataService<T> {
+    protected req: DataRequest;
+    protected dataName: string;
+    protected options: DataRouterOptions<T>;
+    protected data: T[];
+    constructor(req: DataRequest, dataName: string);
+    findOne<TSelect extends Projection | undefined = undefined>(filter: DataFilter<T>, args?: DataFindOneArgs<T, TSelect>, options?: DataFindOneOptions): Promise<SingleResult<SelectedPublicOutput<T, TSelect>> | ErrorResult>;
+    findById<TSelect extends Projection | undefined = undefined>(id: string, args?: DataFindOneArgs<T, TSelect>, options?: DataFindOneOptions): Promise<SingleResult<SelectedPublicOutput<T, TSelect>> | ErrorResult>;
+    find<TSelect extends Projection | undefined = undefined>(filter: DataFilter<T>, args?: DataFindArgs<T, TSelect>, options?: DataFindOptions): Promise<ListResult<SelectedPublicOutput<T, TSelect>> | ErrorResult>;
+    decorate<TDoc>(doc: TDoc, access: DecorateAccess, context?: DataHookContext): Promise<TDoc>;
+    decorateAll<TDoc>(docs: TDoc[], access: DecorateAllAccess, context?: DataHookContext): Promise<TDoc[]>;
+    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    genFilter(access?: BaseFilterAccess, filter?: DataFilter<T>): Promise<DataFilter<T>>;
+    genIDFilter(id: string): Promise<DataFilter<T>>;
+    genSelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    genQuerySelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    pickAllowedFields<TDoc>(doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
+    trimOutputFields<TDoc>(doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
+    private validateSortFields;
+}
+
+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?: string[]): Promise<string[]>;
+    pickAllowedFields<T>(modelName: string, doc: T, access: SelectAccess, baseFields?: string[]): Promise<T>;
+    genSelect(modelName: string, access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    genPopulate(modelName: string, access?: SelectAccess | BaseFilterAccess, _populate?: Populate | Populate[] | string | null): Promise<(string | Populate)[]>;
+    validate(modelName: string, allowedData: unknown, access: ValidateAccess, context: ModelHookContext): Promise<boolean | unknown[]>;
+    prepare<T>(modelName: string, allowedData: T, access: PrepareAccess, context: ModelHookContext): Promise<T>;
+    transform<T>(modelName: string, doc: T, access: TransformAccess, context: ModelHookContext): Promise<T>;
+    afterPersist<T>(modelName: string, doc: T, access: AfterPersistAccess, context: ModelHookContext): Promise<T>;
+    changes(modelName: string, doc: Record<string, unknown>, context: ModelHookContext): Promise<void>;
+    beforeDelete<T>(modelName: string, doc: T, context: ModelHookContext): Promise<void>;
+    afterDelete<T>(modelName: string, doc: T, context: ModelHookContext): Promise<void>;
+    genDocPermissions(modelName: string, doc: unknown, access: DocPermissionsAccess, context: ModelHookContext): Promise<{}>;
+    addEmptyPermissions<T>(modelName: string, doc: T): T;
+    addDocPermissions<T>(modelName: string, doc: T, access: DocPermissionsAccess, context: ModelHookContext): Promise<T>;
+    addFieldPermissions<T extends {
+        _id?: unknown;
+    }>(modelName: string, doc: T, access: DocPermissionsAccess, context: InternalModelHookContext): Promise<T>;
+    decorate<T>(modelName: string, doc: T, access: DecorateAccess, context: ModelHookContext): Promise<T>;
+    decorateAll<T>(modelName: string, docs: T[], access: DecorateAllAccess, context: ModelHookContext): Promise<T[]>;
+    runTasks<T extends object>(modelName: string, docObject: T, task: Task | Task[]): T;
+    getPermissions(): Permission;
+    setPermissions(): Promise<void>;
+    canActivate(routeGuard: Validation): Promise<boolean>;
+    isAllowed(modelName: string, access: RouteGuardAccess | string): Promise<boolean>;
+    getService<TModel = unknown>(modelName: string): Service<TModel>;
+    getPublicService<TModel = unknown>(modelName: string): PublicService<TModel>;
+    service<TModel = unknown>(modelName: string): PublicService<TModel>;
+    svc<TModel = unknown>(modelName: string): PublicService<TModel>;
+    private getGlobalPermissions;
+}
+
+declare class DataCore {
+    private req;
+    private caches;
+    constructor(req: AccessRouterBaseRequest);
+    genIDFilter<TData = unknown>(dataName: string, id: string): Promise<Filter<TData>>;
+    genFilter<TData = unknown>(dataName: string, access?: BaseFilterAccess, _filter?: Filter<TData>): Promise<Filter<TData>>;
+    genAllowedFields(dataName: string, _doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
+    pickAllowedFields<TDoc>(dataName: string, doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
+    genSelect(dataName: string, access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
+    decorate<TDoc>(dataName: string, doc: TDoc, access: DecorateAccess, context?: DataHookContext): Promise<TDoc>;
+    decorateAll<TDoc>(dataName: string, docs: TDoc[], access: DecorateAllAccess, context?: DataHookContext): Promise<TDoc[]>;
+    getPermissions(): Permission;
+    setPermissions(): Promise<void>;
+    canActivate(routeGuard: Validation): Promise<boolean>;
+    isAllowed(dataName: string, access: RouteGuardAccess | string): Promise<boolean>;
+    getService<TData = unknown>(dataName: string): DataService<TData>;
+    service<TData = unknown>(dataName: string): DataService<TData>;
+    svc<TData = unknown>(dataName: string): DataService<TData>;
+    private getGlobalPermissions;
+}
+
+declare enum 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
+}
+
+declare const MIDDLEWARE: unique symbol;
+declare const DATA_MIDDLEWARE: unique symbol;
+declare const PERMISSIONS: unique symbol;
+declare const PERMISSION_KEYS: unique symbol;
+
+interface AccessRouterRequestExtensions {
+    macl?: Core;
+    dacl?: DataCore;
+    [PERMISSIONS]?: AccessRouterPermissions;
+    [PERMISSION_KEYS]?: string[];
+    [MIDDLEWARE]?: unknown[] | unknown;
+    [DATA_MIDDLEWARE]?: unknown[] | unknown;
+    [key: string]: unknown;
+    [key: symbol]: unknown;
+}
+type AccessRouterRequest = express.Request & AccessRouterRequestExtensions;
+
+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;
+}
+
+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 KeyValue {
+    [key: string]: unknown;
+}
+interface Change {
+    op: 'add' | 'replace' | 'remove';
+    path: Array<string | number>;
+    value?: unknown;
+}
+interface ModelHookContext {
+    modelName: string;
+    mongooseModel: mongoose.Model<unknown>;
+    operation?: string;
+    originalDocumentSnapshot?: Record<string, unknown>;
+    finalDocumentSnapshot?: Record<string, unknown>;
+    currentDocument?: ModelDocument;
+    originalData?: Record<string, unknown>;
+    allowedData?: Record<string, unknown>;
+    preparedData?: Record<string, unknown>;
+    allowedFields?: string[];
+    modifiedPaths?: string[];
+    changes?: Change[];
+    docPermissions?: KeyValue;
+    resolvedQuery?: {
+        filter?: Filter;
+        select?: string[];
+        populate?: Populate[] | string;
+        sort?: Sort;
+        skip?: number;
+        limit?: number;
+    };
+}
+interface DataHookContext {
+    dataName?: string;
+    operation?: string;
+    resolvedQuery?: {
+        filter?: Filter;
+        select?: string[];
+        sort?: Sort;
+        skip?: number;
+        limit?: number;
+    };
+}
+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'> {
+    args?: {
+        select?: string[];
+    };
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+    };
+}
+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?: Record<string, never>;
+}
+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> {
+    index: number;
+    target: RootTarget;
+    name: string;
+    op: RootModelOperation | RootDataOperation;
+    result: PublicServiceResult<T, TError>;
+    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;
+    kind: 'error';
+    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>;
+/**
+ * Type-only nominal brand that marks an object as a fully-formed public DTO
+ * produced by one of the `toPublic*` serializers. It has no runtime value, so
+ * the serialized JSON shape is unchanged; its only purpose is to make the
+ * internal {@link SingleResult}/{@link ListResult}/{@link ErrorResult} shapes
+ * structurally incompatible with the public DTOs at the type level. Direct
+ * assignment from an internal service result to a public DTO fails to compile
+ * because the internal result does not carry this brand, and crossing the
+ * boundary requires the explicit serializer (or an explicit cast).
+ */
+declare const publicResultBrand: unique symbol;
+interface PublicErrorResult<TError = unknown> {
+    success: false;
+    code: Codes.BadRequest | Codes.Unauthorized | Codes.Forbidden | Codes.NotFound;
+    errors?: TError[];
+    [publicResultBrand]: 'public-error';
+}
+interface PublicSingleResult<T = unknown> {
+    success: true;
+    kind: 'single';
+    code: Codes.Success | Codes.Created;
+    data: T;
+    [publicResultBrand]: 'public-single';
+}
+interface PublicListResult<T = unknown> {
+    success: true;
+    kind: 'list';
+    code: Codes.Success | Codes.Created;
+    data: T[];
+    count: number;
+    totalCount?: number | null;
+    [publicResultBrand]: 'public-list';
+}
+type PublicServiceResult<T = unknown, TError = unknown> = PublicSingleResult<T> | PublicListResult<T> | PublicErrorResult<TError>;
+
+interface FindArgs<T = unknown> {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    sort?: Sort;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+    overrides?: {
+        filter?: Filter<T>;
+        select?: Projection;
+        populate?: Populate[] | string;
+    };
+}
+interface FindOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    populateAccess?: PopulateAccess;
+    lean?: boolean;
+}
+interface FindOneArgs<T = unknown> {
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    overrides?: {
+        filter?: Filter<T>;
+        select?: Projection;
+        populate?: Populate[] | string;
+    };
+}
+interface FindOneOptions {
+    access?: FindAccess;
+    populateAccess?: PopulateAccess;
+    skim?: boolean;
+    lean?: boolean;
+    includePermissions?: boolean;
+}
+interface FindByIdArgs<T = unknown> {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    overrides?: {
+        select?: Projection;
+        populate?: Populate[] | string;
+        idFilter?: Filter<T>;
+    };
+}
+interface FindByIdOptions extends FindOneOptions {
+}
+
+interface ExistsOptions {
+    access?: BaseFilterAccess;
+    includeId?: boolean;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+type AccessRouterFieldKey<T> = [Extract<keyof T, string>] extends [never] ? string : Extract<keyof T, string>;
+type IdentifierHook<TValue, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, id: string) => MaybePromise<Filter<TValue>>;
+type GlobalPermissionValue = Record<string, boolean> | string[] | string | null | undefined;
+type BaseFilterHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, permissions: AccessRouterPermissions) => MaybePromise<Filter | true | null | undefined>;
+type OverrideFilterHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, filter: Filter, permissions: AccessRouterPermissions) => MaybePromise<Filter>;
+type Hook<TValue, TContext, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, value: TValue, permissions: AccessRouterPermissions, context: TContext) => MaybePromise<TValue>;
+type HookChain<TValue, TContext, TRequest extends AccessRouterRequest = AccessRouterRequest> = Hook<TValue, TContext, TRequest> | Array<Hook<TValue, TContext, TRequest>>;
+type ValidateRule = boolean | unknown[];
+type ValidateHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, allowedData: unknown, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<ValidateRule>;
+type DocPermissionsHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, doc: unknown, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<Record<string, unknown>>;
+type ChangeHook<TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, previousValue: unknown, nextValue: unknown, changes: Change[], context: ModelHookContext) => MaybePromise<void>;
+type DeleteHook<TValue = unknown, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, value: TValue, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<void>;
+type DocumentHook<TValue, TRequest extends AccessRouterRequest = AccessRouterRequest> = (this: TRequest, value: ModelDocument<TValue>, permissions: AccessRouterPermissions, context: ModelHookContext) => MaybePromise<ModelDocument<TValue>>;
+type DocumentHookChain<TValue, TRequest extends AccessRouterRequest = AccessRouterRequest> = DocumentHook<TValue, TRequest> | Array<DocumentHook<TValue, TRequest>>;
+type ModelBaseFilterHook = BaseFilterHook<ModelRequest>;
+type DataBaseFilterHook = BaseFilterHook<DataRequest>;
+type ModelOverrideFilterHook = OverrideFilterHook<ModelRequest>;
+type DataOverrideFilterHook = OverrideFilterHook<DataRequest>;
+type ModelIdentifierHook<TValue = unknown> = IdentifierHook<TValue, ModelRequest>;
+type DataIdentifierHook<TValue = unknown> = IdentifierHook<TValue, DataRequest>;
+type ModelValidateHook = ValidateHook<ModelRequest>;
+type ModelDocPermissionsHook = DocPermissionsHook<ModelRequest>;
+type ModelChangeHook = ChangeHook<ModelRequest>;
+type ModelDocumentHook<TValue = unknown> = DocumentHookChain<TValue, ModelRequest>;
+type ModelDeleteHook<TValue = unknown> = DeleteHook<ModelDocument<TValue>, ModelRequest>;
+type ModelHook<TValue = unknown> = HookChain<TValue, ModelHookContext, ModelRequest>;
+type ModelListHook<TValue = unknown> = HookChain<TValue[], ModelHookContext, ModelRequest>;
+type DataHook<TValue = unknown> = HookChain<TValue, DataHookContext, DataRequest>;
+type DataListHook<TValue = unknown> = HookChain<TValue[], DataHookContext, DataRequest>;
+
+interface DefaultFindOneArgs<TModel = unknown> extends Omit<FindOneArgs<TModel>, 'overrides'> {
+}
+interface DefaultFindByIdArgs<TModel = unknown> extends Omit<FindByIdArgs<TModel>, 'overrides'> {
+}
+interface DefaultFindArgs<TModel = unknown> extends Omit<FindArgs<TModel>, 'overrides'> {
+}
+type RequestSchema = RequestSchemaLike;
+type NestedRequestSchema = {
+    default?: RequestSchema;
+    data?: RequestSchema;
+};
+type SubRouteGuardOptions = Record<string, Validation | Record<string, Validation>>;
+interface RequestSchemas {
+    create?: RequestSchema;
+    update?: RequestSchema;
+    upsert?: RequestSchema;
+    count?: RequestSchema;
+    distinct?: RequestSchema;
+    advancedList?: RequestSchema;
+    advancedReadFilter?: RequestSchema;
+    advancedRead?: RequestSchema;
+    advancedCreate?: RequestSchema | NestedRequestSchema;
+    advancedCreateData?: RequestSchema;
+    advancedUpdate?: RequestSchema | NestedRequestSchema;
+    advancedUpdateData?: RequestSchema;
+    advancedUpsert?: RequestSchema | NestedRequestSchema;
+    advancedUpsertData?: RequestSchema;
+    subList?: RequestSchema;
+    subRead?: RequestSchema;
+    subCreate?: RequestSchema;
+    subUpdate?: RequestSchema;
+    subBulkUpdate?: RequestSchema;
+}
+interface DataRequestSchemas {
+    advancedList?: RequestSchema;
+    advancedReadFilter?: RequestSchema;
+    advancedRead?: RequestSchema;
+}
+interface Defaults<TModel = unknown> {
+    findOneArgs?: DefaultFindOneArgs<TModel>;
+    findOneOptions?: FindOneOptions;
+    findByIdArgs?: DefaultFindByIdArgs<TModel>;
+    findByIdOptions?: FindByIdOptions;
+    findArgs?: DefaultFindArgs<TModel>;
+    findOptions?: FindOptions;
+    createArgs?: CreateArgs;
+    createOptions?: CreateOptions;
+    updateOneArgs?: UpdateOneArgs<TModel>;
+    updateOneOptions?: UpdateOneOptions;
+    upsertOptions?: UpsertOptions;
+    updateByIdArgs?: UpdateByIdArgs<TModel>;
+    upsertArgs?: UpsertArgs<TModel>;
+    updateByIdOptions?: UpdateByIdOptions;
+    existsOptions?: ExistsOptions;
+    publicListArgs?: PublicListArgs;
+    publicListOptions?: PublicListOptions;
+    publicCreateArgs?: PublicCreateArgs;
+    publicCreateOptions?: PublicCreateOptions;
+    publicReadArgs?: PublicReadArgs;
+    publicReadOptions?: PublicReadOptions;
+    publicUpdateArgs?: PublicUpdateArgs;
+    publicUpdateOptions?: PublicUpdateOptions;
+}
+interface AccessRouterLogger {
+    debug?: (...args: unknown[]) => unknown;
+    info?: (...args: unknown[]) => unknown;
+    warn?: (...args: unknown[]) => unknown;
+    error?: (...args: unknown[]) => unknown;
+    isLevelEnabled?: (level: string) => boolean;
+}
+interface GlobalOptions {
+    requestPermissionField?: string;
+    globalPermissions?: (this: AccessRouterRequest, req: AccessRouterRequest) => MaybePromise<GlobalPermissionValue>;
+    logger?: AccessRouterLogger;
+    requestComplexity?: RequestComplexityOptions;
+}
+interface RootRouterOptions {
+    basePath: string;
+    operationAccess?: Validation;
+    maxBatchEntries?: number;
+    maxOrderGroups?: number;
+    maxConcurrentOperations?: number;
+}
+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.upsert'?: Validation;
+    'operationAccess.delete'?: Validation;
+    'operationAccess.create'?: Validation;
+    'operationAccess.distinct'?: Validation;
+    'operationAccess.count'?: Validation;
+    'operationAccess.subs'?: SubRouteGuardOptions;
+}
+interface ModelRouterOptions<TModel = unknown> extends DefaultModelRouterOptions<TModel> {
+    modelName?: string;
+    basePath?: string;
+    permissionSchema?: PermissionSchema<AccessRouterFieldKey<TModel>>;
+    alwaysSelectFields?: string[];
+    docPermissions?: DocPermissions | ModelDocPermissionsHook;
+    baseFilter?: ModelBaseFilterHook | Record<string, ModelBaseFilterHook>;
+    overrideFilter?: ModelOverrideFilterHook | Record<string, ModelOverrideFilterHook>;
+    decorate?: ModelHook<TModel> | Record<string, ModelHook<TModel>>;
+    decorateAll?: ModelListHook<TModel> | Record<string, ModelListHook<TModel>>;
+    validate?: ValidateRule | ModelValidateHook | Record<string, ValidateRule | ModelValidateHook>;
+    prepare?: ModelHook<TModel> | Record<string, ModelHook<TModel>>;
+    transform?: ModelDocumentHook<TModel> | Record<string, ModelDocumentHook<TModel>>;
+    afterPersist?: ModelDocumentHook<TModel> | Record<string, ModelDocumentHook<TModel>>;
+    onChange?: Record<string, ModelChangeHook>;
+    beforeDelete?: ModelDeleteHook<TModel>;
+    afterDelete?: ModelDeleteHook<TModel>;
+    requestSchemas?: RequestSchemas;
+    defaults?: Defaults<TModel>;
+}
+interface DataRouterOptions<TData = unknown> {
+    data?: TData[];
+    listHardLimit?: number;
+    idParam?: string;
+    idField?: string;
+    resolveIdFilter?: DataIdentifierHook<TData>;
+    parentPath?: string;
+    queryRouteSegment?: string;
+    operationAccess?: Validation | OperationAccess;
+    dataName?: string;
+    basePath?: string;
+    permissionSchema?: PermissionSchema<AccessRouterFieldKey<TData>>;
+    baseFilter?: DataBaseFilterHook | Record<string, DataBaseFilterHook>;
+    overrideFilter?: DataOverrideFilterHook | Record<string, DataOverrideFilterHook>;
+    decorate?: DataHook<TData> | Record<string, DataHook<TData>>;
+    decorateAll?: DataListHook<TData> | Record<string, DataListHook<TData>>;
+    requestSchemas?: DataRequestSchemas;
+}
+interface ExtendedModelRouterOptions<TModel = unknown> extends ModelRouterOptions<TModel>, ExtendedDefaultModelRouterOptions<TModel> {
+    'alwaysSelectFields.default'?: string[];
+    'alwaysSelectFields.list'?: string[];
+    'alwaysSelectFields.create'?: string[];
+    'alwaysSelectFields.read'?: string[];
+    'alwaysSelectFields.update'?: string[];
+    'docPermissions.default'?: ModelDocPermissionsHook;
+    'docPermissions.list'?: ModelDocPermissionsHook;
+    'docPermissions.create'?: ModelDocPermissionsHook;
+    'docPermissions.read'?: ModelDocPermissionsHook;
+    'docPermissions.update'?: ModelDocPermissionsHook;
+    'baseFilter.default'?: ModelBaseFilterHook;
+    'baseFilter.list'?: ModelBaseFilterHook;
+    'baseFilter.read'?: ModelBaseFilterHook;
+    'baseFilter.update'?: ModelBaseFilterHook;
+    'baseFilter.delete'?: ModelBaseFilterHook;
+    'overrideFilter.default'?: ModelOverrideFilterHook;
+    'overrideFilter.list'?: ModelOverrideFilterHook;
+    'overrideFilter.read'?: ModelOverrideFilterHook;
+    'overrideFilter.update'?: ModelOverrideFilterHook;
+    'overrideFilter.delete'?: ModelOverrideFilterHook;
+    'decorate.default'?: ModelHook;
+    'decorate.list'?: ModelHook;
+    'decorate.create'?: ModelHook;
+    'decorate.read'?: ModelHook;
+    'decorate.update'?: ModelHook;
+    'decorateAll.default'?: ModelListHook;
+    'decorateAll.list'?: ModelListHook;
+    'validate.default'?: ValidateRule | ModelValidateHook;
+    'validate.create'?: ValidateRule | ModelValidateHook;
+    'validate.update'?: ValidateRule | ModelValidateHook;
+    'prepare.default'?: ModelHook;
+    'prepare.create'?: ModelHook;
+    'prepare.update'?: ModelHook;
+    'transform.default'?: ModelDocumentHook;
+    'transform.update'?: ModelDocumentHook;
+    'afterPersist.default'?: ModelDocumentHook;
+    'afterPersist.create'?: ModelDocumentHook;
+    'afterPersist.update'?: ModelDocumentHook;
+    onChange?: Record<string, ModelChangeHook>;
+    'requestSchemas.create'?: RequestSchema;
+    'requestSchemas.update'?: RequestSchema;
+    'requestSchemas.upsert'?: RequestSchema;
+    'requestSchemas.count'?: RequestSchema;
+    'requestSchemas.distinct'?: RequestSchema;
+    'requestSchemas.advancedList'?: RequestSchema;
+    'requestSchemas.advancedReadFilter'?: RequestSchema;
+    'requestSchemas.advancedRead'?: RequestSchema;
+    'requestSchemas.advancedCreate.default'?: RequestSchema;
+    'requestSchemas.advancedCreate.data'?: RequestSchema;
+    'requestSchemas.advancedUpdate'?: RequestSchema;
+    'requestSchemas.advancedUpdate.default'?: RequestSchema;
+    'requestSchemas.advancedUpdate.data'?: RequestSchema;
+    'requestSchemas.advancedUpsert.default'?: RequestSchema;
+    'requestSchemas.advancedUpsert.data'?: RequestSchema;
+    'requestSchemas.subList'?: RequestSchema;
+    'requestSchemas.subRead'?: RequestSchema;
+    'requestSchemas.subCreate'?: RequestSchema;
+    'requestSchemas.subUpdate'?: RequestSchema;
+    'requestSchemas.subBulkUpdate'?: RequestSchema;
+    'defaults.findOneArgs'?: DefaultFindOneArgs<TModel>;
+    'defaults.findOneOptions'?: FindOneOptions;
+    'defaults.findByIdArgs'?: DefaultFindByIdArgs<TModel>;
+    'defaults.findByIdOptions'?: FindByIdOptions;
+    'defaults.findArgs'?: DefaultFindArgs<TModel>;
+    'defaults.findOptions'?: FindOptions;
+    'defaults.createArgs'?: CreateArgs;
+    'defaults.createOptions'?: CreateOptions;
+    'defaults.updateOneArgs'?: UpdateOneArgs<TModel>;
+    'defaults.updateOneOptions'?: UpdateOneOptions;
+    'defaults.updateByIdArgs'?: UpdateByIdArgs<TModel>;
+    'defaults.updateByIdOptions'?: UpdateByIdOptions;
+    'defaults.upsertArgs'?: UpsertArgs<TModel>;
+    'defaults.existsOptions'?: ExistsOptions;
+    'defaults.publicListArgs'?: PublicListArgs;
+    'defaults.publicListOptions'?: PublicListOptions;
+    'defaults.publicCreateArgs'?: PublicCreateArgs;
+    'defaults.publicCreateOptions'?: PublicCreateOptions;
+    'defaults.publicReadArgs'?: PublicReadArgs;
+    'defaults.publicReadOptions'?: PublicReadOptions;
+    'defaults.publicUpdateArgs'?: PublicUpdateArgs;
+    'defaults.publicUpdateOptions'?: PublicUpdateOptions;
+}
+interface ExtendedDataRouterOptions<TData = unknown> extends DataRouterOptions<TData> {
+    'requestSchemas.advancedList'?: RequestSchema;
+    'requestSchemas.advancedReadFilter'?: RequestSchema;
+    'requestSchemas.advancedRead'?: RequestSchema;
+}
+
+interface DistinctArgs<T = unknown> {
+    filter?: Filter<T>;
+}
+type SubdocumentId = string;
+type SubdocumentName = string;
+type SubdocumentRecord = Record<string, unknown>;
+type SubdocumentBulkRecord = SubdocumentRecord & {
+    _id?: unknown;
+};
+type SubdocumentCreateInput = SubdocumentRecord | SubdocumentRecord[];
+type SubdocumentBulkUpdateInput = SubdocumentBulkRecord[];
+interface SubdocumentListOptions<T = unknown> {
+    filter?: Filter<T>;
+    select?: string[];
+}
+interface SubdocumentReadOptions {
+    select?: string[];
+    populate?: SubPopulate | SubPopulate[];
+}
+interface SubdocumentCreateOptions {
+    addFirst?: boolean;
+}
+interface SubdocumentParentArgs {
+    populate?: SubPopulate | SubPopulate[];
+}
+interface SubdocumentParentOptions {
+    access?: BaseFilterAccess;
+    lean?: boolean;
+}
+
+declare function parsePathParam(value: string | string[] | undefined, parameter: string): string;
+declare function parseQuery<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+declare function parseBody<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+declare function parseBodyWithSchema<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown, userSchema?: RequestSchemaLike): Promise<z.output<TSchema>>;
+declare function parseNestedBodyWithSchema(schema: z.ZodTypeAny, value: unknown, nestedKey: string, userSchema?: RequestSchemaLike): Promise<Record<string, unknown>>;
+/**
+ * Wraps a request validator into a request schema adapter used by `access-router`.
+ *
+ * @example
+ * const schema = defineRequestSchema(fromZod(z.object({ name: z.string() })));
+ */
+declare function defineRequestSchema<T = unknown>(validator: RequestSchemaValidator<T>, options?: RequestSchemaOptions): RequestSchemaAdapter<T>;
+/**
+ * Adapts a Zod schema into a `RequestSchemaValidator` for `access-router`.
+ *
+ * @example
+ * const validator = fromZod(z.object({ name: z.string() }));
+ */
+declare function fromZod<TSchema extends z.ZodTypeAny>(schema: TSchema): RequestSchemaValidator<z.output<TSchema>>;
+declare function fromStandardSchema<TSchema extends StandardSchemaV1>(schema: TSchema): RequestSchemaValidator<StandardSchemaInferOutput<TSchema>>;
+declare function fromYup<TSchema extends YupSchemaLike>(schema: TSchema): RequestSchemaValidator;
+declare function fromJoi<TSchema extends JoiSchemaLike>(schema: TSchema): RequestSchemaValidator;
+declare function fromAjv<TValue = unknown>(validator: AjvValidatorLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromValibot<TSchema, TOutput = unknown>(schema: TSchema, safeParse: ValibotSafeParseLike): RequestSchemaValidator<TOutput>;
+declare function fromArkType<TValue = unknown>(type: ArkTypeLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromIoTs<TValue = unknown>(decoder: IoTsDecoderLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromSuperstruct<TStruct, TOutput = unknown>(struct: TStruct, validate: SuperstructValidateLike): RequestSchemaValidator<TOutput>;
+declare function fromVine<TValue = unknown>(validator: VineValidatorLike<TValue>): RequestSchemaValidator<TValue>;
+
+export { type Filter as $, type AccessRouterBaseRequest as A, type BaseFilterAccess as B, type Change as C, DATA_MIDDLEWARE as D, type DataFindOneOptions as E, type DataFindOptions as F, type DataHook as G, type DataHookContext as H, type DataIdentifierHook as I, type DataListHook as J, type DataOverrideFilterHook as K, type DataRequest as L, type DataRequestSchemas as M, type DataRouterOptions as N, type DecorateAccess as O, type DecorateAllAccess as P, type DeepFieldPath as Q, type DefaultModelRouterOptions as R, type Defaults as S, type DistinctArgs as T, type DistinctBody as U, type DocPermissionsAccess as V, type ErrorResult as W, type ExistsOptions as X, type ExtendedDataRouterOptions as Y, type ExtendedDefaultModelRouterOptions as Z, type ExtendedModelRouterOptions as _, type AccessRouterFieldKey as a, type RequestSchemaFailure as a$, FilterOperator as a0, type FindAccess as a1, type FindArgs as a2, type FindByIdArgs as a3, type FindByIdOptions as a4, type FindOneArgs as a5, type FindOneOptions as a6, type FindOptions as a7, type GlobalOptions as a8, type GlobalPermissionValue as a9, type ModelValidateHook as aA, PERMISSIONS as aB, PERMISSION_KEYS as aC, type PathValue as aD, type PermissionSchema as aE, type Populate as aF, type PopulateAccess as aG, type PrepareAccess as aH, type Projection as aI, type PublicCreateArgs as aJ, type PublicCreateOptions as aK, type PublicErrorResult as aL, type PublicListArgs as aM, type PublicListOptions as aN, type PublicListResult as aO, type PublicOutput as aP, type PublicReadArgs as aQ, type PublicReadOptions as aR, type PublicServiceResult as aS, type PublicSingleResult as aT, type PublicUpdateArgs as aU, type PublicUpdateOptions as aV, type PublicUpsertArgs as aW, type PublicUpsertOptions as aX, type ReadQueryInput as aY, type Request as aZ, type RequestSchemaAdapter as a_, type GuardHook as aa, type IdentifierHook as ab, type Include as ac, type IoTsContextEntryLike as ad, type IoTsDecodeErrorLike as ae, type IoTsDecoderLike as af, type JoiSchemaLike as ag, type JoiValidationErrorDetailLike as ah, type KeyValueProjection as ai, type ListQueryInput as aj, type ListResult as ak, MIDDLEWARE as al, type MaybePromise as am, type ModelBaseFilterHook as an, type ModelChangeHook as ao, type ModelDeleteHook as ap, type ModelDocPermissionsHook as aq, type ModelDocument as ar, type ModelDocumentHook as as, type ModelHook as at, type ModelHookContext as au, type ModelIdentifierHook as av, type ModelListHook as aw, type ModelOverrideFilterHook as ax, type ModelRequest as ay, type ModelRouterOptions as az, type AccessRouterLogger as b, type SubdocumentRecord as b$, type RequestSchemaIssue as b0, type RequestSchemaLike as b1, type RequestSchemaOptions as b2, type RequestSchemaResult as b3, type RequestSchemaSuccess as b4, type RequestSchemaValidator as b5, type RequestSchemas as b6, type RootDataListQueryEntry as b7, type RootDataOperation as b8, type RootDataReadByFilterQueryEntry as b9, type SelectedPublicOutput as bA, type ServiceResult as bB, type SingleResult as bC, type Sort as bD, type SortOrder as bE, type StandardSchemaFailure as bF, type StandardSchemaInferOutput as bG, type StandardSchemaIssue as bH, type StandardSchemaPathSegment as bI, type StandardSchemaResult as bJ, type StandardSchemaSuccess as bK, type StandardSchemaV1 as bL, StatusCodes as bM, type SubListBody as bN, type SubPopulate as bO, type SubQueryEntry as bP, type SubReadBody as bQ, type SubdocumentBulkRecord as bR, type SubdocumentBulkUpdateInput as bS, type SubdocumentCreateInput as bT, type SubdocumentCreateOptions as bU, type SubdocumentId as bV, type SubdocumentListOptions as bW, type SubdocumentName as bX, type SubdocumentParentArgs as bY, type SubdocumentParentOptions as bZ, type SubdocumentReadOptions as b_, type RootDataReadByIdQueryEntry as ba, type RootModelCountQueryEntry as bb, type RootModelCreateQueryEntry as bc, type RootModelDeleteQueryEntry as bd, type RootModelDistinctQueryEntry as be, type RootModelListQueryEntry as bf, type RootModelNewQueryEntry as bg, type RootModelOperation as bh, type RootModelReadByFilterQueryEntry as bi, type RootModelReadByIdQueryEntry as bj, type RootModelSubBulkUpdateQueryEntry as bk, type RootModelSubCreateQueryEntry as bl, type RootModelSubDeleteQueryEntry as bm, type RootModelSubListQueryEntry as bn, type RootModelSubReadQueryEntry as bo, type RootModelSubUpdateQueryEntry as bp, type RootModelUpdateQueryEntry as bq, type RootModelUpsertQueryEntry as br, type RootOperationResult as bs, type RootQueryEntry as bt, type RootRouterOptions as bu, type RootSubOperation as bv, type RootTarget as bw, type RouteGuardAccess as bx, type SelectAccess as by, type SelectedPopulatedPublicOutput as bz, type AccessRouterRequest as c, type SuperstructFailureLike as c0, type SuperstructValidateLike as c1, type Task as c2, type TransformAccess as c3, type TypedFilter as c4, type UpdateByIdArgs as c5, type UpdateByIdOptions as c6, type UpdateOneArgs as c7, type UpdateOneOptions as c8, type UpdateQueryInput as c9, fromZod as cA, parseBody as cB, parseBodyWithSchema as cC, parseNestedBodyWithSchema as cD, parsePathParam as cE, parseQuery as cF, AccessRuntime as cG, DataService as cH, Model as cI, Service as cJ, PublicService as cK, type OpenApiRouterOptions as cL, type OpenApiRegistryOptions as cM, type OpenApiRouteDescriptor as cN, type OpenApiDocumentOptions as cO, type OpenApiParameter as cP, type OpenApiSchema as cQ, type OpenApiResponses as cR, type AccessRouterPermissionMap as cS, type AccessRouterPermissions as cT, type OpenApiMethod as cU, type Permissions as cV, defaultRuntime as cW, type UpsertArgs as ca, type UpsertOptions as cb, type UpsertQueryInput as cc, type ValibotIssueLike as cd, type ValibotPathItemLike as ce, type ValibotSafeParseLike as cf, type ValibotSafeParseResult as cg, type ValidateAccess as ch, type ValidateRule as ci, type Validation as cj, type ValidationError as ck, type VineValidationErrorLike as cl, type VineValidationMessageLike as cm, type VineValidatorLike as cn, type YupSchemaLike as co, type YupValidationErrorLike as cp, defineRequestSchema as cq, fromAjv as cr, fromArkType as cs, fromIoTs as ct, fromJoi as cu, fromStandardSchema as cv, fromSuperstruct as cw, fromValibot as cx, fromVine as cy, fromYup as cz, type AccessRouterRequestExtensions as d, type AdvancedCreateBody as e, type AdvancedListBody as f, type AdvancedReadBody as g, type AdvancedReadFilterBody as h, type AdvancedUpdateBody as i, type AdvancedUpsertBody as j, type AfterPersistAccess as k, type AjvErrorObjectLike as l, type AjvValidatorLike as m, type ArkTypeErrorsLike as n, type ArkTypeLike as o, type ArkTypeProblemLike as p, Codes as q, type CountBody as r, type CreateArgs as s, type CreateOptions as t, type CreateQueryInput as u, CustomHeaders as v, type DataBaseFilterHook as w, type DataFilter as x, type DataFindArgs as y, type DataFindOneArgs as z };