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

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@web-ts-toolkit/access-router",
-  "description": "Access-policy Express routers and in-memory data services for Mongoose-backed APIs",
-  "version": "0.3.0",
+  "description": "ACL-aware Express routers and in-memory data services for Mongoose-backed APIs",
+  "homepage": "https://web-ts-toolkit.pages.dev/docs/packages/access-router",
+  "version": "0.5.0",
+  "sideEffects": false,
   "keywords": [
     "express",
     "mongoose",
-    "access",
+    "acl",
+    "crud",
+    "openapi",
     "access-router",
     "router"
   ],
@@ -32,12 +36,15 @@
       "default": "./processors.js"
     }
   },
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
-    "@web-ts-toolkit/express-json-router": "0.3.0",
+    "@web-ts-toolkit/express-json-router": "0.5.0",
+    "@web-ts-toolkit/utils": "0.5.0",
     "deep-diff": "^1.0.2",
     "mongoose-schema-jsonschema": "^4.0.1",
     "sift": "^17.1.3",
-    "@web-ts-toolkit/utils": "0.3.0",
     "winston": "^3.19.0",
     "zod": "^4.1.12"
   },
@@ -49,9 +56,6 @@
   "bugs": {
     "url": "https://github.com/egose/web-ts-toolkit/issues"
   },
-  "engines": {
-    "node": ">=20"
-  },
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/{service-DLKAswCS.d.mts → parsers-Ce1grlLx.d.mts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import express from 'express';
 import mongoose from 'mongoose';
 import { Diff } from 'deep-diff';
+import express from 'express';
 
 interface BooleanObject {
     [key: string]: boolean;
@@ -26,8 +26,8 @@ type Permissions = Permission;
 type AccessRouterPermissions = Permission;
 
 declare class Base<TModel = unknown> {
-    req: ModelRequest;
-    modelName: string;
+    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[]>;
@@ -98,19 +98,17 @@ declare class Model {
     find({ filter, select, sort, populate, limit, skip, lean }: FindProps): mongoose.Query<any[], any, {}, any, "find", {}>;
     validateSort(sort: SortType, logError?: (msg: string, ...args: unknown[]) => void): boolean;
     findOne({ filter, select, sort, populate, lean }: FindOneProps): mongoose.Query<any, any, {}, any, "findOne", {}>;
-    findOneAndDelete(filter: any): mongoose.Query<any, any, {}, any, "findOneAndDelete", {}>;
     exists(filter: any): mongoose.Query<any, any, {}, any, "findOne", {}>;
     countDocuments(filter?: {}): mongoose.Query<number, any, {}, any, "countDocuments", {}>;
-    estimatedDocumentCount(): mongoose.Query<number, any, {}, any, "estimatedDocumentCount", {}>;
     distinct(field: string, conditions?: {}): mongoose.Query<any[], any, {}, any, "distinct", {}>;
 }
 
 declare class Service<TModel = unknown> extends Base<TModel> {
-    model: Model;
-    options: ModelRouterOptions<TModel>;
+    protected model: Model;
+    protected options: ModelRouterOptions<TModel>;
     defaults: Defaults<TModel>;
-    baseFields: string[];
-    baseFieldsExt: string[];
+    protected baseFields: string[];
+    protected baseFieldsExt: string[];
     private asServiceHookContext;
     constructor(req: ModelRequest, modelName: string);
     findOne(filter: Filter<TModel>, args?: FindOneArgs<TModel>, options?: FindOneOptions): Promise<SingleResult<TModel> | ErrorResult>;
@@ -210,10 +208,10 @@ declare class PublicService<TModel = unknown> extends Service<TModel> {
 }
 
 declare class DataService<T> {
-    req: DataRequest;
-    dataName: string;
-    options: DataRouterOptions<T>;
-    data: 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>;
@@ -865,39 +863,327 @@ type ModelListHook<TValue = unknown> = HookChain<TValue[], ModelHookContext, Mod
 type DataHook<TValue = unknown> = HookChain<TValue, DataHookContext, DataRequest>;
 type DataListHook<TValue = unknown> = HookChain<TValue[], DataHookContext, DataRequest>;
 
+type ValidationError = {
+    detail: string;
+    pointer?: string;
+    parameter?: string;
+};
+type RequestSchemaIssue = {
+    message: string;
+    path?: Array<string | number>;
+};
+type RequestSchemaSuccess<T = unknown> = {
+    success: true;
+    data: T;
+};
+type RequestSchemaFailure = {
+    success: false;
+    issues: RequestSchemaIssue[];
+};
+type RequestSchemaResult<T = unknown> = RequestSchemaSuccess<T> | RequestSchemaFailure;
+type RequestSchemaValidator<T = unknown> = (value: unknown) => RequestSchemaResult<T> | Promise<RequestSchemaResult<T>>;
+type RequestSchemaAdapter<T = unknown> = {
+    validate: RequestSchemaValidator<T>;
+    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[];
+    options?: {
+        access?: unknown;
+    };
+};
+type AdvancedReadFilterBody = {
+    filter?: Filter | unknown[];
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        tryList?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedReadBody = {
+    select?: Projection;
+    populate?: Populate[] | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+    options?: {
+        skim?: boolean;
+        includePermissions?: boolean;
+        tryList?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedCreateBody = {
+    data: unknown;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedUpdateBody = {
+    data: unknown;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        returningAll?: boolean;
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type AdvancedUpsertBody = {
+    data: Record<string, unknown>;
+    select?: Projection;
+    populate?: Populate[] | string;
+    tasks?: Task | Task[];
+    options?: {
+        returningAll?: boolean;
+        includePermissions?: boolean;
+        populateAccess?: unknown;
+    };
+};
+type DistinctBody = {
+    filter?: Filter | unknown[];
+};
+type SubListBody = {
+    filter?: Filter;
+    select?: string[];
+};
+type SubReadBody = {
+    select?: string[];
+    populate?: SubPopulate | SubPopulate[] | string | string[];
+};
+
 interface DefaultFindOneArgs<TModel = unknown> extends Omit<FindOneArgs<TModel>, 'overrides'> {
 }
 interface DefaultFindByIdArgs<TModel = unknown> extends Omit<FindByIdArgs<TModel>, 'overrides'> {
 }
 interface DefaultFindArgs<TModel = unknown> extends Omit<FindArgs<TModel>, 'overrides'> {
 }
-type RequestZodSchema = z.ZodTypeAny;
+type RequestSchema = RequestSchemaLike;
+type NestedRequestSchema = {
+    default?: RequestSchema;
+    data?: RequestSchema;
+};
 type SubRouteGuardOptions = Record<string, Validation | Record<string, Validation>>;
 interface RequestSchemas {
-    create?: RequestZodSchema;
-    update?: RequestZodSchema;
-    upsert?: RequestZodSchema;
-    count?: RequestZodSchema;
-    distinct?: RequestZodSchema;
-    advancedList?: RequestZodSchema;
-    advancedReadFilter?: RequestZodSchema;
-    advancedRead?: RequestZodSchema;
-    advancedCreate?: RequestZodSchema;
-    advancedCreateData?: RequestZodSchema;
-    advancedUpdate?: RequestZodSchema;
-    advancedUpdateData?: RequestZodSchema;
-    advancedUpsert?: RequestZodSchema;
-    advancedUpsertData?: RequestZodSchema;
-    subList?: RequestZodSchema;
-    subRead?: RequestZodSchema;
-    subCreate?: RequestZodSchema;
-    subUpdate?: RequestZodSchema;
-    subBulkUpdate?: RequestZodSchema;
+    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?: RequestZodSchema;
-    advancedReadFilter?: RequestZodSchema;
-    advancedRead?: RequestZodSchema;
+    advancedList?: RequestSchema;
+    advancedReadFilter?: RequestSchema;
+    advancedRead?: RequestSchema;
 }
 interface Defaults<TModel = unknown> {
     findOneArgs?: DefaultFindOneArgs<TModel>;
@@ -1061,26 +1347,26 @@ interface ExtendedModelRouterOptions<TModel = unknown> extends ModelRouterOption
     'afterPersist.create'?: ModelDocumentHook;
     'afterPersist.update'?: ModelDocumentHook;
     onChange?: Record<string, ModelChangeHook>;
-    'requestSchemas.create'?: RequestZodSchema;
-    'requestSchemas.update'?: RequestZodSchema;
-    'requestSchemas.upsert'?: RequestZodSchema;
-    'requestSchemas.count'?: RequestZodSchema;
-    'requestSchemas.distinct'?: RequestZodSchema;
-    'requestSchemas.advancedList'?: RequestZodSchema;
-    'requestSchemas.advancedReadFilter'?: RequestZodSchema;
-    'requestSchemas.advancedRead'?: RequestZodSchema;
-    'requestSchemas.advancedCreate.default'?: RequestZodSchema;
-    'requestSchemas.advancedCreate.data'?: RequestZodSchema;
-    'requestSchemas.advancedUpdate'?: RequestZodSchema;
-    'requestSchemas.advancedUpdate.default'?: RequestZodSchema;
-    'requestSchemas.advancedUpdate.data'?: RequestZodSchema;
-    'requestSchemas.advancedUpsert.default'?: RequestZodSchema;
-    'requestSchemas.advancedUpsert.data'?: RequestZodSchema;
-    'requestSchemas.subList'?: RequestZodSchema;
-    'requestSchemas.subRead'?: RequestZodSchema;
-    'requestSchemas.subCreate'?: RequestZodSchema;
-    'requestSchemas.subUpdate'?: RequestZodSchema;
-    'requestSchemas.subBulkUpdate'?: RequestZodSchema;
+    '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>;
@@ -1105,13 +1391,30 @@ interface ExtendedModelRouterOptions<TModel = unknown> extends ModelRouterOption
     'defaults.publicUpdateOptions'?: PublicUpdateOptions;
 }
 interface ExtendedDataRouterOptions<TData = unknown> extends DataRouterOptions<TData> {
-    'requestSchemas.advancedList'?: RequestZodSchema;
-    'requestSchemas.advancedReadFilter'?: RequestZodSchema;
-    'requestSchemas.advancedRead'?: RequestZodSchema;
+    'requestSchemas.advancedList'?: RequestSchema;
+    'requestSchemas.advancedReadFilter'?: RequestSchema;
+    'requestSchemas.advancedRead'?: RequestSchema;
 }
 
 interface DistinctArgs<T = unknown> {
     filter?: Filter<T>;
 }
 
-export { type GlobalPermissionValue as $, type AccessRouterBaseRequest as A, type BaseFilterAccess as B, Codes as C, type DataBaseFilterHook as D, type DefaultModelRouterOptions as E, type Filter as F, type Defaults as G, type DistinctArgs as H, type Include as I, type DocPermissionsAccess as J, type ErrorResult as K, type ExistsOptions as L, type ExtendedDataRouterOptions as M, type ExtendedDefaultModelRouterOptions as N, type ExtendedModelRouterOptions as O, type Projection as P, FilterOperator as Q, type FindAccess as R, type Sort as S, type Task as T, type FindArgs as U, type FindByIdArgs as V, type FindByIdOptions as W, type FindOneArgs as X, type FindOneOptions as Y, type FindOptions as Z, type GlobalOptions as _, type Populate as a, type SelectAccess as a$, type GuardHook as a0, type IdentifierHook as a1, type KeyValueProjection as a2, type ListResult as a3, type MaybePromise as a4, type ModelBaseFilterHook as a5, type ModelChangeHook as a6, type ModelDeleteHook as a7, type ModelDocPermissionsHook as a8, type ModelDocument as a9, type RootDataListQueryEntry as aA, type RootDataOperation as aB, type RootDataReadByFilterQueryEntry as aC, type RootDataReadByIdQueryEntry as aD, type RootModelCountQueryEntry as aE, type RootModelCreateQueryEntry as aF, type RootModelDeleteQueryEntry as aG, type RootModelDistinctQueryEntry as aH, type RootModelListQueryEntry as aI, type RootModelNewQueryEntry as aJ, type RootModelOperation as aK, type RootModelReadByFilterQueryEntry as aL, type RootModelReadByIdQueryEntry as aM, type RootModelSubBulkUpdateQueryEntry as aN, type RootModelSubCreateQueryEntry as aO, type RootModelSubDeleteQueryEntry as aP, type RootModelSubListQueryEntry as aQ, type RootModelSubReadQueryEntry as aR, type RootModelSubUpdateQueryEntry as aS, type RootModelUpdateQueryEntry as aT, type RootModelUpsertQueryEntry as aU, type RootOperationResult as aV, type RootQueryEntry as aW, type RootRouterOptions as aX, type RootSubOperation as aY, type RootTarget as aZ, type RouteGuardAccess as a_, type ModelDocumentHook as aa, type ModelHook as ab, type ModelHookContext as ac, type ModelIdentifierHook as ad, type ModelListHook as ae, type ModelOverrideFilterHook as af, type ModelRequest as ag, type ModelRouterOptions as ah, type ModelValidateHook as ai, type PathValue as aj, type PermissionSchema as ak, type PopulateAccess as al, type PrepareAccess as am, type PublicCreateArgs as an, type PublicCreateOptions as ao, type PublicListArgs as ap, type PublicListOptions as aq, type PublicOutput as ar, type PublicReadArgs as as, type PublicReadOptions as at, type PublicUpdateArgs as au, type PublicUpdateOptions as av, type PublicUpsertArgs as aw, type PublicUpsertOptions as ax, type Request as ay, type RequestSchemas as az, type SubPopulate as b, type SelectedPopulatedPublicOutput as b0, type SelectedPublicOutput as b1, type ServiceResult as b2, type SingleResult as b3, type SortOrder as b4, StatusCodes as b5, type SubQueryEntry as b6, type TransformAccess as b7, type TypedFilter as b8, type UpdateByIdArgs as b9, type UpdateByIdOptions as ba, type UpdateOneArgs as bb, type UpdateOneOptions as bc, type UpsertArgs as bd, type UpsertOptions as be, type ValidateAccess as bf, type ValidateRule as bg, type Validation as bh, DataService as bi, Model as bj, Service as bk, PublicService as bl, type AccessRouterPermissionMap as bm, type AccessRouterPermissions as bn, type Permissions as bo, type AccessRouterFieldKey as c, type AccessRouterLogger as d, type AccessRouterRequest as e, type AccessRouterRequestExtensions as f, type AfterPersistAccess as g, type CreateArgs as h, type CreateOptions as i, CustomHeaders as j, type DataFilter as k, type DataFindArgs as l, type DataFindOneArgs as m, type DataFindOneOptions as n, type DataFindOptions as o, type DataHook as p, type DataHookContext as q, type DataIdentifierHook as r, type DataListHook as s, type DataOverrideFilterHook as t, type DataRequest as u, type DataRequestSchemas as v, type DataRouterOptions as w, type DecorateAccess as x, type DecorateAllAccess as y, type DeepFieldPath as z };
+declare function parsePathParam(value: string | string[] | undefined, parameter: string): string;
+declare function parseQuery<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+declare function parseBody<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+declare function parseBodyWithSchema<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown, userSchema?: RequestSchemaLike): Promise<z.output<TSchema>>;
+declare function parseNestedBodyWithSchema(schema: z.ZodTypeAny, value: unknown, nestedKey: string, userSchema?: RequestSchemaLike): Promise<Record<string, unknown>>;
+declare function defineRequestSchema<T = unknown>(validator: RequestSchemaValidator<T>, options?: RequestSchemaOptions): RequestSchemaAdapter<T>;
+declare function fromZod<TSchema extends z.ZodTypeAny>(schema: TSchema): RequestSchemaValidator<z.output<TSchema>>;
+declare function fromStandardSchema<TSchema extends StandardSchemaV1>(schema: TSchema): RequestSchemaValidator<StandardSchemaInferOutput<TSchema>>;
+declare function fromYup<TSchema extends YupSchemaLike>(schema: TSchema): RequestSchemaValidator;
+declare function fromJoi<TSchema extends JoiSchemaLike>(schema: TSchema): RequestSchemaValidator;
+declare function fromAjv<TValue = unknown>(validator: AjvValidatorLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromValibot<TSchema, TOutput = unknown>(schema: TSchema, safeParse: ValibotSafeParseLike): RequestSchemaValidator<TOutput>;
+declare function fromArkType<TValue = unknown>(type: ArkTypeLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromIoTs<TValue = unknown>(decoder: IoTsDecoderLike<TValue>): RequestSchemaValidator<TValue>;
+declare function fromSuperstruct<TStruct, TOutput = unknown>(struct: TStruct, validate: SuperstructValidateLike): RequestSchemaValidator<TOutput>;
+declare function fromVine<TValue = unknown>(validator: VineValidatorLike<TValue>): RequestSchemaValidator<TValue>;
+
+export { type FindAccess as $, type AccessRouterBaseRequest as A, type BaseFilterAccess as B, Codes as C, type DataBaseFilterHook as D, type DataHook as E, type DataHookContext as F, type DataIdentifierHook as G, type DataListHook as H, type DataOverrideFilterHook as I, type DataRequest as J, type DataRequestSchemas as K, type DataRouterOptions as L, type DecorateAccess as M, type DecorateAllAccess as N, type DeepFieldPath as O, type DefaultModelRouterOptions as P, type Defaults as Q, type DistinctArgs as R, type DistinctBody as S, type DocPermissionsAccess as T, type ErrorResult as U, type ExistsOptions as V, type ExtendedDataRouterOptions as W, type ExtendedDefaultModelRouterOptions as X, type ExtendedModelRouterOptions as Y, type Filter as Z, FilterOperator as _, type AccessRouterFieldKey as a, type RootDataOperation as a$, type FindArgs as a0, type FindByIdArgs as a1, type FindByIdOptions as a2, type FindOneArgs as a3, type FindOneOptions as a4, type FindOptions as a5, type GlobalOptions as a6, type GlobalPermissionValue as a7, type GuardHook as a8, type IdentifierHook as a9, type Populate as aA, type PopulateAccess as aB, type PrepareAccess as aC, type Projection as aD, type PublicCreateArgs as aE, type PublicCreateOptions as aF, type PublicListArgs as aG, type PublicListOptions as aH, type PublicOutput as aI, type PublicReadArgs as aJ, type PublicReadOptions as aK, type PublicUpdateArgs as aL, type PublicUpdateOptions as aM, type PublicUpsertArgs as aN, type PublicUpsertOptions as aO, type ReadQueryInput as aP, type Request as aQ, type RequestSchemaAdapter as aR, type RequestSchemaFailure as aS, type RequestSchemaIssue as aT, type RequestSchemaLike as aU, type RequestSchemaOptions as aV, type RequestSchemaResult as aW, type RequestSchemaSuccess as aX, type RequestSchemaValidator as aY, type RequestSchemas as aZ, type RootDataListQueryEntry as a_, type Include as aa, type IoTsContextEntryLike as ab, type IoTsDecodeErrorLike as ac, type IoTsDecoderLike as ad, type JoiSchemaLike as ae, type JoiValidationErrorDetailLike as af, type KeyValueProjection as ag, type ListQueryInput as ah, type ListResult as ai, type MaybePromise as aj, type ModelBaseFilterHook as ak, type ModelChangeHook as al, type ModelDeleteHook as am, type ModelDocPermissionsHook as an, type ModelDocument as ao, type ModelDocumentHook as ap, type ModelHook as aq, type ModelHookContext as ar, type ModelIdentifierHook as as, type ModelListHook as at, type ModelOverrideFilterHook as au, type ModelRequest as av, type ModelRouterOptions as aw, type ModelValidateHook as ax, type PathValue as ay, type PermissionSchema as az, type AccessRouterLogger as b, type Validation as b$, type RootDataReadByFilterQueryEntry as b0, type RootDataReadByIdQueryEntry as b1, type RootModelCountQueryEntry as b2, type RootModelCreateQueryEntry as b3, type RootModelDeleteQueryEntry as b4, type RootModelDistinctQueryEntry as b5, type RootModelListQueryEntry as b6, type RootModelNewQueryEntry as b7, type RootModelOperation as b8, type RootModelReadByFilterQueryEntry as b9, type StandardSchemaResult as bA, type StandardSchemaSuccess as bB, type StandardSchemaV1 as bC, StatusCodes as bD, type SubListBody as bE, type SubPopulate as bF, type SubQueryEntry as bG, type SubReadBody as bH, type SuperstructFailureLike as bI, type SuperstructValidateLike as bJ, type Task as bK, type TransformAccess as bL, type TypedFilter as bM, type UpdateByIdArgs as bN, type UpdateByIdOptions as bO, type UpdateOneArgs as bP, type UpdateOneOptions as bQ, type UpdateQueryInput as bR, type UpsertArgs as bS, type UpsertOptions as bT, type UpsertQueryInput as bU, type ValibotIssueLike as bV, type ValibotPathItemLike as bW, type ValibotSafeParseLike as bX, type ValibotSafeParseResult as bY, type ValidateAccess as bZ, type ValidateRule as b_, type RootModelReadByIdQueryEntry as ba, type RootModelSubBulkUpdateQueryEntry as bb, type RootModelSubCreateQueryEntry as bc, type RootModelSubDeleteQueryEntry as bd, type RootModelSubListQueryEntry as be, type RootModelSubReadQueryEntry as bf, type RootModelSubUpdateQueryEntry as bg, type RootModelUpdateQueryEntry as bh, type RootModelUpsertQueryEntry as bi, type RootOperationResult as bj, type RootQueryEntry as bk, type RootRouterOptions as bl, type RootSubOperation as bm, type RootTarget as bn, type RouteGuardAccess as bo, type SelectAccess as bp, type SelectedPopulatedPublicOutput as bq, type SelectedPublicOutput as br, type ServiceResult as bs, type SingleResult as bt, type Sort as bu, type SortOrder as bv, type StandardSchemaFailure as bw, type StandardSchemaInferOutput as bx, type StandardSchemaIssue as by, type StandardSchemaPathSegment as bz, type AccessRouterRequest as c, type ValidationError as c0, type VineValidationErrorLike as c1, type VineValidationMessageLike as c2, type VineValidatorLike as c3, type YupSchemaLike as c4, type YupValidationErrorLike as c5, defineRequestSchema as c6, fromAjv as c7, fromArkType as c8, fromIoTs as c9, fromJoi as ca, fromStandardSchema as cb, fromSuperstruct as cc, fromValibot as cd, fromVine as ce, fromYup as cf, fromZod as cg, parseBody as ch, parseBodyWithSchema as ci, parseNestedBodyWithSchema as cj, parsePathParam as ck, parseQuery as cl, DataService as cm, Model as cn, Service as co, PublicService as cp, type AccessRouterPermissionMap as cq, type AccessRouterPermissions as cr, type Permissions as cs, type AccessRouterRequestExtensions as d, type AdvancedCreateBody as e, type AdvancedListBody as f, type AdvancedReadBody as g, type AdvancedReadFilterBody as h, type AdvancedUpdateBody as i, type AdvancedUpsertBody as j, type AfterPersistAccess as k, type AjvErrorObjectLike as l, type AjvValidatorLike as m, type ArkTypeErrorsLike as n, type ArkTypeLike as o, type ArkTypeProblemLike as p, type CountBody as q, type CreateArgs as r, type CreateOptions as s, type CreateQueryInput as t, CustomHeaders as u, type DataFilter as v, type DataFindArgs as w, type DataFindOneArgs as x, type DataFindOneOptions as y, type DataFindOptions as z };