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;

declare class Service<TModel = unknown> extends Base<TModel> {
    protected model: any;
    protected options: ModelRouterOptions<TModel>;
    defaults: Defaults<TModel>;
    protected baseFields: string[];
    protected baseFieldsExt: string[];
    findRawParentDoc(args: {
        filter: Filter<TModel>;
        select: string;
        populate: unknown;
        lean: boolean;
    }): any;
    protected createModelAdapter(modelName: string): any;
    protected getModelRouterOptions(modelName: string): ModelRouterOptions<TModel>;
    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>;
    /**
     * Trusted count for correlated includes (ACI-03): the caller already
     * resolved parent references, revalidated expanded operands, and applied
     * explicit `count` access via `genFilter`. This skips client-filter
     * validation and subquery parsing so substituted parent data stays inert.
     */
    countTrusted(authorizedFilter: Filter<TModel>): Promise<SingleResult<number> | ErrorResult>;
    countByFieldValues(foreignField: string, values: unknown[], filter?: Filter<TModel>, access?: BaseFilterAccess): Promise<SingleResult<Map<string, Set<string>>> | 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 = {
    name: 'ValidationError';
    message: string;
    errors: ReadonlyArray<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 AjvValidationErrorLike = {
    errors?: ReadonlyArray<AjvErrorObjectLike> | null;
};
type AjvValidatorLike<T = unknown> = {
    (value: unknown): boolean | Promise<T | boolean>;
    errors?: ReadonlyArray<AjvErrorObjectLike> | null;
    $async?: boolean;
};
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;
    readonly arkKind?: string;
    readonly ' arkKind'?: string;
};
type ArkTypeLike<T = unknown> = {
    (value: unknown): T | ArkTypeErrorsLike | Promise<T | ArkTypeErrorsLike>;
    errors?: unknown;
    readonly '~standard'?: StandardSchemaV1['~standard'];
};
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 = {
    name?: string;
    code?: string;
    status?: number;
    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;
    maxHookConcurrency?: number;
    maxCorrelatedQueries?: number;
    maxCorrelatedDepth?: number;
}

declare class RequestConcurrencyScheduler {
    readonly limit: number;
    constructor(limit: number);
    map<TInput, TOutput>(items: TInput[], iteratee: (item: TInput, index: number, scheduled: true) => Promise<TOutput>): Promise<TOutput[]>;
    run<TOutput>(iteratee: (scheduled: true) => Promise<TOutput>): Promise<TOutput>;
}

type CrossResourceModelOperation = 'list' | 'read' | 'count';
interface CorrelatedExecState {
    totalQueries: number;
    scheduler: RequestConcurrencyScheduler;
}
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, subPaths?: string[]): 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: LegacyInclude[];
        correlatedIncludes: CorrelatedInclude[];
        includeLocalFields: string[];
        includePaths: string[];
        correlatedReferenceFields: string[];
    };
    private getForeignKeyValues;
    private getForeignKey;
    private buildForeignKeyIndex;
    private getIndexedMatches;
    private getIndexedCount;
    private sanitizeIncludeArgs;
    private assertIncludeForeignField;
    protected includeDocs<TDoc>(docs: TDoc | TDoc[], include: Include | Include[]): Promise<TDoc | TDoc[]>;
    private includeDocsRead;
    private includeDocsList;
    private includeDocsCount;
    protected getCorrelatedExecState(): CorrelatedExecState;
    protected claimCorrelatedQuerySlot(): void;
    private sanitizeCorrelatedArgs;
    protected includeCorrelatedDocs<TDoc>(docs: TDoc[], correlatedIncludes: CorrelatedInclude[], snapshots?: unknown[], depth?: number): Promise<TDoc[]>;
    private includeCorrelatedRead;
    private includeCorrelatedList;
    private includeCorrelatedCount;
    protected parseClientData<TValue>(filter: TValue, scheduler?: RequestConcurrencyScheduler, scheduled?: boolean): 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[]>;
    getRequestComplexity(): Required<RequestComplexityOptions>;
    genAllowedFields(doc: unknown, access: SelectAccess, baseFields?: string[]): Promise<string[]>;
    genFilter(access?: BaseFilterAccess, filter?: DataFilter<T>): Promise<DataFilter<T>>;
    genIDFilter(id: string): Promise<DataFilter<T>>;
    genSelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
    genQuerySelect(access: SelectAccess, targetFields?: Projection, skipChecks?: boolean, subPaths?: string[]): Promise<string[]>;
    pickAllowedFields<TDoc>(doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
    trimOutputFields<TDoc>(doc: TDoc, access: SelectAccess, baseFields?: string[]): Promise<TDoc>;
}

type InternalModelHookContext = ModelHookContext & {
    fieldPermissionAccess?: {
        readIds?: Set<string>;
        updateIds?: Set<string>;
    };
};
declare class Core {
    private req;
    private caches;
    private cachedPermissions;
    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, subPaths?: string[]): 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;
    private cachedPermissions;
    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?: Sort;
    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 Unwrap<T> = NonNullable<Descend<T>>;
type DeepFieldPath<T, Depth extends number = 4> = [Depth] extends [never] ? never : Unwrap<T> extends NonTraversable ? never : {
    [K in Extract<keyof Unwrap<T>, string>]: K | (NonNullable<Unwrap<T>[K]> extends NonTraversable ? never : NonNullable<Unwrap<T>[K]> extends readonly (infer U)[] ? Unwrap<U> extends NonTraversable ? never : `${K}.${DeepFieldPath<U, PrevDepth[Depth]>}` : NonNullable<Unwrap<T>[K]> extends object ? `${K}.${DeepFieldPath<NonNullable<Unwrap<T>[K]>, PrevDepth[Depth]>}` : never);
}[Extract<keyof Unwrap<T>, string>];
type PathValue<T, TPath extends string> = TPath extends `${infer Head}.${infer Tail}` ? Head extends Extract<keyof Unwrap<T>, string> ? PathValue<Unwrap<Unwrap<T>[Head]>, Tail> : unknown : TPath extends Extract<keyof Unwrap<T>, string> ? Unwrap<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 LegacyInclude {
    mode?: 'legacy';
    model: string;
    op: 'list' | 'read' | 'count';
    path: string;
    filter?: Filter;
    localField: string;
    foreignField: string;
    args?: unknown;
    options?: unknown;
}
/**
 * Explicit structural marker referencing a field of the immediate parent
 * document (ACI-01 D2.1). Recognized only in filter/id value positions of
 * correlated includes; magic `$field` strings are never markers.
 */
interface ParentRef {
    $parent: string;
}
/** Filter template for correlated includes; values may carry {@link ParentRef} markers. */
type CorrelatedFilter = Record<string, unknown>;
interface CorrelatedIncludeArgs {
    select?: Projection;
    sort?: Sort;
    skip?: number | string;
    limit?: number | string;
    page?: number | string;
    pageSize?: number | string;
    include?: Include | Include[];
}
interface CorrelatedIncludeBase {
    mode: 'correlated';
    model: string;
    op: 'list' | 'read' | 'count';
    path: string;
    args?: CorrelatedIncludeArgs;
    options?: Record<string, never>;
}
/** Identifier read: exactly one of `id` / `filter` must be present. */
interface CorrelatedReadByIdInclude extends CorrelatedIncludeBase {
    op: 'read';
    id: string | ParentRef;
    filter?: never;
}
interface CorrelatedReadByFilterInclude extends CorrelatedIncludeBase {
    op: 'read';
    filter: CorrelatedFilter;
    id?: never;
}
interface CorrelatedListInclude extends CorrelatedIncludeBase {
    op: 'list';
    filter: CorrelatedFilter;
    id?: never;
}
interface CorrelatedCountInclude extends CorrelatedIncludeBase {
    op: 'count';
    filter: CorrelatedFilter;
    id?: never;
}
type CorrelatedInclude = CorrelatedReadByIdInclude | CorrelatedReadByFilterInclude | CorrelatedListInclude | CorrelatedCountInclude;
type Include = LegacyInclude | CorrelatedInclude;
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;
    };
}
type TaskType = 'COPY_AND_DEPOPULATE' | 'COPY' | 'MOVE' | 'SLICE' | 'COUNT' | 'MASK' | string;
interface Task {
    type: TaskType;
    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>;
    /** Require populate target models to be registered in the active runtime. Defaults to `true`. */
    requireRegisteredPopulateModels?: boolean;
    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> {
    /**
     * In-memory records are owned by the router as an immutable configured snapshot.
     * Mutating this array or its records after configuration does not change served data;
     * use `setDataOption(name, 'data', nextRecords)` or `router.data(nextRecords)` to replace it.
     */
    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<TModel>;
    'decorate.list'?: ModelHook<TModel>;
    'decorate.create'?: ModelHook<TModel>;
    'decorate.read'?: ModelHook<TModel>;
    'decorate.update'?: ModelHook<TModel>;
    'decorateAll.default'?: ModelListHook<TModel>;
    'decorateAll.list'?: ModelListHook<TModel>;
    'validate.default'?: ValidateRule | ModelValidateHook;
    'validate.create'?: ValidateRule | ModelValidateHook;
    'validate.update'?: ValidateRule | ModelValidateHook;
    'prepare.default'?: ModelHook<TModel>;
    'prepare.create'?: ModelHook<TModel>;
    'prepare.update'?: ModelHook<TModel>;
    'transform.default'?: ModelDocumentHook<TModel>;
    'transform.update'?: ModelDocumentHook<TModel>;
    'afterPersist.default'?: ModelDocumentHook<TModel>;
    'afterPersist.create'?: ModelDocumentHook<TModel>;
    'afterPersist.update'?: ModelDocumentHook<TModel>;
    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`.
 *
 * Supports both synchronous schemas and schemas with async refinements or
 * transforms via `safeParseAsync` when available. Synchronous schemas keep
 * their existing output values and issue paths. Operational exceptions thrown
 * by `safeParseAsync` itself propagate unchanged.
 *
 * @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;
/**
 * Adapts an AJV validator into a `RequestSchemaValidator`.
 *
 * Contract: synchronous validators return a boolean and expose input-local
 * diagnostics via mutable `validator.errors`; those errors are snapshotted
 * synchronously before any suspension so concurrent same-turn validations do
 * not observe another input's diagnostics. Asynchronous AJV schemas
 * (`$async: true`) return a promise that resolves with validated data on
 * success or rejects with a `ValidationError` carrying an `errors` array on
 * failure; rejection-carried errors are normalized, while any other rejection
 * propagates unchanged as an operational exception.
 */
declare function fromAjv<TValue = unknown>(validator: AjvValidatorLike<TValue>): RequestSchemaValidator<TValue>;
declare function fromValibot<TSchema, TOutput = unknown>(schema: TSchema, safeParse: ValibotSafeParseLike): RequestSchemaValidator<TOutput>;
/**
 * Adapts an ArkType type into a `RequestSchemaValidator`.
 *
 * Success/failure is discriminated via the supported ArkErrors brand key
 * (`hasArkKind(result, "errors")`, stored at runtime as `' arkKind'` with a
 * leading space; the unspaced `arkKind` alias is also accepted) or, when the
 * type exposes a Standard Schema `~standard.validate` contract, via that
 * contract. ArkType's Standard Schema `validate` returns `{ value }` on
 * success but returns raw `ArkErrors` on failure instead of `{ issues }`, so
 * both shapes are handled. Array shape and `message`/`path`-like record
 * fields are never used as discriminators, so valid empty/scalar/record/
 * nullable arrays pass through unchanged. Unexpected exceptions thrown by the
 * type propagate unchanged.
 */
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 DistinctArgs as $, type AccessRouterBaseRequest as A, type BaseFilterAccess as B, type Change as C, type CreateArgs as D, type CreateOptions as E, type CreateQueryInput as F, CustomHeaders as G, DATA_MIDDLEWARE as H, type DataBaseFilterHook as I, type DataFilter as J, type DataFindArgs as K, type DataFindOneArgs as L, type DataFindOneOptions as M, type DataFindOptions as N, type DataHook as O, type DataHookContext as P, type DataIdentifierHook as Q, type DataListHook as R, type DataOverrideFilterHook as S, type DataRequest as T, type DataRequestSchemas as U, type DataRouterOptions as V, type DecorateAccess as W, type DecorateAllAccess as X, type DeepFieldPath as Y, type DefaultModelRouterOptions as Z, type Defaults as _, type AccessRouterFieldKey as a, type PublicReadOptions as a$, type DistinctBody as a0, type DocPermissionsAccess as a1, type ErrorResult as a2, type ExistsOptions as a3, type ExtendedDataRouterOptions as a4, type ExtendedDefaultModelRouterOptions as a5, type ExtendedModelRouterOptions as a6, type Filter as a7, FilterOperator as a8, type FindAccess as a9, type ModelDocument as aA, type ModelDocumentHook as aB, type ModelHook as aC, type ModelHookContext as aD, type ModelIdentifierHook as aE, type ModelListHook as aF, type ModelOverrideFilterHook as aG, type ModelRequest as aH, type ModelRouterOptions as aI, type ModelValidateHook as aJ, PERMISSIONS as aK, PERMISSION_KEYS as aL, type ParentRef as aM, type PathValue as aN, type PermissionSchema as aO, type Populate as aP, type PopulateAccess as aQ, type PrepareAccess as aR, type Projection as aS, type PublicCreateArgs as aT, type PublicCreateOptions as aU, type PublicErrorResult as aV, type PublicListArgs as aW, type PublicListOptions as aX, type PublicListResult as aY, type PublicOutput as aZ, type PublicReadArgs as a_, type FindArgs as aa, type FindByIdArgs as ab, type FindByIdOptions as ac, type FindOneArgs as ad, type FindOneOptions as ae, type FindOptions as af, type GlobalOptions as ag, type GlobalPermissionValue as ah, type GuardHook as ai, type IdentifierHook as aj, type Include as ak, type IoTsContextEntryLike as al, type IoTsDecodeErrorLike as am, type IoTsDecoderLike as an, type JoiSchemaLike as ao, type JoiValidationErrorDetailLike as ap, type KeyValueProjection as aq, type LegacyInclude as ar, type ListQueryInput as as, type ListResult as at, MIDDLEWARE as au, type MaybePromise as av, type ModelBaseFilterHook as aw, type ModelChangeHook as ax, type ModelDeleteHook as ay, type ModelDocPermissionsHook as az, type AccessRouterLogger as b, type SubdocumentBulkRecord as b$, type PublicServiceResult as b0, type PublicSingleResult as b1, type PublicUpdateArgs as b2, type PublicUpdateOptions as b3, type PublicUpsertArgs as b4, type PublicUpsertOptions as b5, type ReadQueryInput as b6, type Request as b7, type RequestSchemaAdapter as b8, type RequestSchemaFailure as b9, type RootModelUpdateQueryEntry as bA, type RootModelUpsertQueryEntry as bB, type RootOperationResult as bC, type RootQueryEntry as bD, type RootRouterOptions as bE, type RootSubOperation as bF, type RootTarget as bG, type RouteGuardAccess as bH, type SelectAccess as bI, type SelectedPopulatedPublicOutput as bJ, type SelectedPublicOutput as bK, type ServiceResult as bL, type SingleResult as bM, type Sort as bN, type SortOrder as bO, type StandardSchemaFailure as bP, type StandardSchemaInferOutput as bQ, type StandardSchemaIssue as bR, type StandardSchemaPathSegment as bS, type StandardSchemaResult as bT, type StandardSchemaSuccess as bU, type StandardSchemaV1 as bV, StatusCodes as bW, type SubListBody as bX, type SubPopulate as bY, type SubQueryEntry as bZ, type SubReadBody as b_, type RequestSchemaIssue as ba, type RequestSchemaLike as bb, type RequestSchemaOptions as bc, type RequestSchemaResult as bd, type RequestSchemaSuccess as be, type RequestSchemaValidator as bf, type RequestSchemas as bg, type RootDataListQueryEntry as bh, type RootDataOperation as bi, type RootDataReadByFilterQueryEntry as bj, type RootDataReadByIdQueryEntry as bk, type RootModelCountQueryEntry as bl, type RootModelCreateQueryEntry as bm, type RootModelDeleteQueryEntry as bn, type RootModelDistinctQueryEntry as bo, type RootModelListQueryEntry as bp, type RootModelNewQueryEntry as bq, type RootModelOperation as br, type RootModelReadByFilterQueryEntry as bs, type RootModelReadByIdQueryEntry as bt, type RootModelSubBulkUpdateQueryEntry as bu, type RootModelSubCreateQueryEntry as bv, type RootModelSubDeleteQueryEntry as bw, type RootModelSubListQueryEntry as bx, type RootModelSubReadQueryEntry as by, type RootModelSubUpdateQueryEntry as bz, type AccessRouterRequest as c, type SubdocumentBulkUpdateInput as c0, type SubdocumentCreateInput as c1, type SubdocumentCreateOptions as c2, type SubdocumentId as c3, type SubdocumentListOptions as c4, type SubdocumentName as c5, type SubdocumentParentArgs as c6, type SubdocumentParentOptions as c7, type SubdocumentReadOptions as c8, type SubdocumentRecord as c9, type YupValidationErrorLike as cA, defineRequestSchema as cB, fromAjv as cC, fromArkType as cD, fromIoTs as cE, fromJoi as cF, fromStandardSchema as cG, fromSuperstruct as cH, fromValibot as cI, fromVine as cJ, fromYup as cK, fromZod as cL, parseBody as cM, parseBodyWithSchema as cN, parseNestedBodyWithSchema as cO, parsePathParam as cP, parseQuery as cQ, DataService as cR, Service as cS, PublicService as cT, type AccessRouterPermissionMap as cU, type AccessRouterPermissions as cV, type Permissions as cW, type SuperstructFailureLike as ca, type SuperstructValidateLike as cb, type Task as cc, type TaskType as cd, type TransformAccess as ce, type TypedFilter as cf, type UpdateByIdArgs as cg, type UpdateByIdOptions as ch, type UpdateOneArgs as ci, type UpdateOneOptions as cj, type UpdateQueryInput as ck, type UpsertArgs as cl, type UpsertOptions as cm, type UpsertQueryInput as cn, type ValibotIssueLike as co, type ValibotPathItemLike as cp, type ValibotSafeParseLike as cq, type ValibotSafeParseResult as cr, type ValidateAccess as cs, type ValidateRule as ct, type Validation as cu, type ValidationError as cv, type VineValidationErrorLike as cw, type VineValidationMessageLike as cx, type VineValidatorLike as cy, type YupSchemaLike 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 AjvValidationErrorLike as m, type AjvValidatorLike as n, type ArkTypeErrorsLike as o, type ArkTypeLike as p, type ArkTypeProblemLike as q, Codes as r, type CorrelatedCountInclude as s, type CorrelatedFilter as t, type CorrelatedInclude as u, type CorrelatedIncludeArgs as v, type CorrelatedListInclude as w, type CorrelatedReadByFilterInclude as x, type CorrelatedReadByIdInclude as y, type CountBody as z };