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

package/advanced.mjs

@@ -0,0 +1,941 @@
+// src/symbols.ts
+var MIDDLEWARE = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/middleware");
+var DATA_MIDDLEWARE = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/data-middleware");
+var CORE = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/core");
+var PERMISSIONS = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/permissions");
+var PERMISSION_KEYS = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/access-router/permission-keys");
+
+// src/enums.ts
+var StatusCodes = /* @__PURE__ */ ((StatusCodes2) => {
+  StatusCodes2[StatusCodes2["OK"] = 200] = "OK";
+  StatusCodes2[StatusCodes2["Created"] = 201] = "Created";
+  StatusCodes2[StatusCodes2["BadRequest"] = 400] = "BadRequest";
+  StatusCodes2[StatusCodes2["Unauthorized"] = 401] = "Unauthorized";
+  StatusCodes2[StatusCodes2["Forbidden"] = 403] = "Forbidden";
+  StatusCodes2[StatusCodes2["NotFound"] = 404] = "NotFound";
+  StatusCodes2[StatusCodes2["UnprocessableContent"] = 422] = "UnprocessableContent";
+  return StatusCodes2;
+})(StatusCodes || {});
+var Codes = /* @__PURE__ */ ((Codes2) => {
+  Codes2["Success"] = "success";
+  Codes2["Created"] = "created";
+  Codes2["BadRequest"] = "bad_request";
+  Codes2["Unauthorized"] = "unauthorized";
+  Codes2["Forbidden"] = "forbidden";
+  Codes2["NotFound"] = "not_found";
+  return Codes2;
+})(Codes || {});
+var CustomHeaders = /* @__PURE__ */ ((CustomHeaders2) => {
+  CustomHeaders2["TotalCount"] = "wtt-total-count";
+  CustomHeaders2["ReturnedCount"] = "wtt-returned-count";
+  CustomHeaders2["Page"] = "wtt-page";
+  CustomHeaders2["PageSize"] = "wtt-page-size";
+  CustomHeaders2["TotalPages"] = "wtt-total-pages";
+  CustomHeaders2["HasNextPage"] = "wtt-has-next-page";
+  CustomHeaders2["HasPreviousPage"] = "wtt-has-previous-page";
+  return CustomHeaders2;
+})(CustomHeaders || {});
+var FilterOperator = /* @__PURE__ */ ((FilterOperator2) => {
+  FilterOperator2[FilterOperator2["SubQuery"] = 0] = "SubQuery";
+  FilterOperator2[FilterOperator2["Date"] = 1] = "Date";
+  return FilterOperator2;
+})(FilterOperator || {});
+
+// src/validation/parsers.ts
+import JsonRouter from "@web-ts-toolkit/express-json-router";
+
+// src/validation/common.ts
+import { z } from "zod";
+var stringOrStringArray = z.union([z.string(), z.array(z.string())]);
+var queryBooleanString = z.enum(["true", "false"]);
+var positiveIntegerString = z.string().regex(/^\d+$/, "Expected a non-negative integer");
+var nonNegativeIntegerSchema = z.number().int().min(0);
+var unknownRecord = z.record(z.string(), z.unknown());
+var projectionObjectSchema = z.record(z.string(), z.union([z.literal(1), z.literal(-1)]));
+var projectionSchema = z.union([z.string(), z.array(z.string()), projectionObjectSchema]);
+var sortOrderSchema = z.union([
+  z.literal(-1),
+  z.literal(1),
+  z.literal("asc"),
+  z.literal("ascending"),
+  z.literal("desc"),
+  z.literal("descending")
+]);
+var sortSchema = z.union([
+  z.string(),
+  z.record(z.string(), sortOrderSchema),
+  z.array(z.tuple([z.string(), sortOrderSchema])),
+  z.null()
+]);
+var populateSchema = z.union([
+  z.string(),
+  z.array(
+    z.union([
+      z.string(),
+      z.object({
+        path: z.string().min(1),
+        select: projectionSchema.optional(),
+        match: z.unknown().optional(),
+        access: z.enum(["list", "read"]).optional()
+      }).passthrough()
+    ])
+  ),
+  z.object({
+    path: z.string().min(1),
+    select: projectionSchema.optional(),
+    match: z.unknown().optional(),
+    access: z.enum(["list", "read"]).optional()
+  }).passthrough()
+]);
+var subPopulateSchema = z.union([
+  z.string(),
+  z.array(
+    z.union([
+      z.string(),
+      z.object({
+        path: z.string().min(1),
+        select: projectionSchema.optional()
+      }).passthrough()
+    ])
+  ),
+  z.object({
+    path: z.string().min(1),
+    select: projectionSchema.optional()
+  }).passthrough()
+]);
+var includeItemSchema = z.object({
+  model: z.string().min(1),
+  op: z.enum(["list", "read", "count"]),
+  path: z.string().min(1),
+  filter: z.record(z.string(), z.unknown()).optional(),
+  localField: z.string().min(1),
+  foreignField: z.string().min(1),
+  args: z.unknown().optional(),
+  options: z.unknown().optional()
+}).passthrough();
+var includeSchema = z.union([includeItemSchema, z.array(includeItemSchema)]);
+var fieldsSchema = z.array(z.string().min(1));
+var taskSchema = z.object({
+  type: z.string().min(1),
+  args: z.unknown(),
+  options: unknownRecord.optional()
+});
+var tasksSchema = z.union([taskSchema, z.array(taskSchema)]);
+var objectOrArraySchema = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())]);
+function rejectKeys(body, ctx, keys) {
+  for (const key of keys) {
+    if (key in body) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Unsupported field: ${key}`,
+        path: [key]
+      });
+    }
+  }
+}
+
+// src/validation/parsers.ts
+var clientErrors = JsonRouter.clientErrors;
+function parsePathParam(value, parameter) {
+  const result = stringOrStringArray.safeParse(value);
+  if (!result.success) {
+    throwValidationError(normalizeIssues(result.error.issues), parameter, "parameter");
+  }
+  const param = Array.isArray(result.data) ? result.data[0] : result.data;
+  if (!param) {
+    throw new clientErrors.BadRequestError("Bad Request", {
+      errors: [{ detail: "Required", parameter }]
+    });
+  }
+  return param;
+}
+function parseQuery(schema, value) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    throwValidationError(normalizeIssues(result.error.issues), void 0, "parameter");
+  }
+  return result.data;
+}
+function parseBody(schema, value) {
+  const result = schema.safeParse(value ?? {});
+  if (!result.success) {
+    throwValidationError(normalizeIssues(result.error.issues), void 0, "pointer");
+  }
+  return result.data;
+}
+function parseBodyWithSchema(schema, value, userSchema) {
+  const body = parseBody(schema, value);
+  return isRequestSchema(userSchema) ? parseUserSchema(userSchema, body) : Promise.resolve(body);
+}
+async function parseNestedBodyWithSchema(schema, value, nestedKey, userSchema) {
+  const body = parseBody(schema, value);
+  if (!isRequestSchema(userSchema)) return body;
+  return {
+    ...body,
+    [nestedKey]: await parseUserSchema(userSchema, body?.[nestedKey], [nestedKey])
+  };
+}
+function throwValidationError(issues, key, location = "pointer") {
+  const errors = issues.map((issue) => formatIssue(issue, key, location));
+  throw new clientErrors.BadRequestError("Bad Request", { errors });
+}
+async function parseUserSchema(schema, value, prefix = []) {
+  const validator = toRequestSchemaValidator(schema);
+  const result = await validator(value);
+  if (!isRequestSchemaFailure(result)) {
+    return result.data;
+  }
+  const issues = result.issues.map((issue) => ({
+    ...issue,
+    path: prefix.concat((issue.path ?? []).map(String))
+  }));
+  throwValidationError(issues, void 0, "pointer");
+}
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function";
+}
+function isRequestSchema(schema) {
+  return isZodSchema(schema) || isStandardSchema(schema) || isRequestSchemaValidator(schema) || isRequestSchemaAdapter(schema);
+}
+function isRequestSchemaValidator(schema) {
+  return typeof schema === "function";
+}
+function isRequestSchemaAdapter(schema) {
+  return typeof schema === "object" && schema !== null && "validate" in schema && typeof schema.validate === "function";
+}
+function isStandardSchema(schema) {
+  return typeof schema === "object" && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "validate" in schema["~standard"] && typeof schema["~standard"].validate === "function";
+}
+function isRequestSchemaFailure(result) {
+  return result.success === false;
+}
+function toRequestSchemaValidator(schema) {
+  if (isZodSchema(schema)) return fromZod(schema);
+  if (isStandardSchema(schema)) return fromStandardSchema(schema);
+  if (isRequestSchemaValidator(schema)) return schema;
+  return schema.validate;
+}
+function defineRequestSchema(validator) {
+  return validator;
+}
+function fromZod(schema) {
+  return (value) => {
+    const result = schema.safeParse(value);
+    if (result.success) {
+      return {
+        success: true,
+        data: result.data
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIssues(result.error.issues)
+    };
+  };
+}
+function fromStandardSchema(schema) {
+  return async (value) => {
+    const result = await schema["~standard"].validate(value);
+    if (!isStandardSchemaFailure(result)) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIssues(result.issues)
+    };
+  };
+}
+function fromYup(schema) {
+  return async (value) => {
+    try {
+      const data = await schema.validate(value, { abortEarly: false });
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeYupIssues(error)
+      };
+    }
+  };
+}
+function fromJoi(schema) {
+  return async (value) => {
+    const result = await schema.validate(value, { abortEarly: false });
+    if (!result.error?.details?.length) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeJoiIssues(result.error.details)
+    };
+  };
+}
+function fromAjv(validator) {
+  return async (value) => {
+    const valid = await validator(value);
+    if (valid) {
+      return {
+        success: true,
+        data: value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeAjvIssues(validator.errors ?? [])
+    };
+  };
+}
+function fromValibot(schema, safeParse) {
+  return async (value) => {
+    const result = await safeParse(schema, value, { abortEarly: false });
+    if (result.success) {
+      return {
+        success: true,
+        data: result.output
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeValibotIssues(result.issues)
+    };
+  };
+}
+function fromArkType(type) {
+  return async (value) => {
+    const result = await type(value);
+    if (!isArkTypeErrors(result)) {
+      return {
+        success: true,
+        data: result
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeArkTypeIssues(result)
+    };
+  };
+}
+function fromIoTs(decoder) {
+  return async (value) => {
+    const result = decoder.decode(value);
+    if (result._tag === "Right") {
+      return {
+        success: true,
+        data: result.right
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIoTsIssues(result.left)
+    };
+  };
+}
+function fromSuperstruct(struct, validate) {
+  return async (value) => {
+    const [failure, output] = await validate(value, struct);
+    if (!failure) {
+      return {
+        success: true,
+        data: output
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeSuperstructFailure(failure)
+    };
+  };
+}
+function fromVine(validator) {
+  return async (value) => {
+    try {
+      const output = await validator.validate(value);
+      return {
+        success: true,
+        data: output
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeVineError(error)
+      };
+    }
+  };
+}
+function isStandardSchemaFailure(result) {
+  return Array.isArray(result.issues);
+}
+function normalizeIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path?.flatMap((segment) => normalizePathSegment(segment))
+  }));
+}
+function normalizePathSegment(segment) {
+  const key = isStandardSchemaPathSegment(segment) ? segment.key : segment;
+  return typeof key === "string" || typeof key === "number" ? [key] : [];
+}
+function isStandardSchemaPathSegment(segment) {
+  return typeof segment === "object" && segment !== null && "key" in segment;
+}
+function normalizeYupIssues(error) {
+  if (!isYupValidationError(error)) {
+    return [{ message: "Validation failed" }];
+  }
+  const issues = error.inner?.length ? error.inner : [error];
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: parsePathString(issue.path)
+  }));
+}
+function normalizeJoiIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path ? [...issue.path] : void 0
+  }));
+}
+function normalizeAjvIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message ?? "Validation failed",
+    path: parseAjvPath(issue)
+  }));
+}
+function normalizeValibotIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path?.flatMap(
+      (item) => typeof item.key === "string" || typeof item.key === "number" ? [item.key] : []
+    )
+  }));
+}
+function normalizeArkTypeIssues(issues) {
+  const normalized = issues.map((issue) => ({
+    message: issue.message ?? issue.problem ?? issues.summary ?? "Validation failed",
+    path: issue.path ? [...issue.path] : void 0
+  }));
+  return normalized.length ? normalized : [{ message: issues.summary ?? "Validation failed" }];
+}
+function normalizeIoTsIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message ?? "Validation failed",
+    path: issue.context.map((entry) => entry.key).filter(Boolean)
+  }));
+}
+function normalizeSuperstructFailure(failure) {
+  const failures = failure.failures?.() ?? [failure];
+  return failures.map((entry) => ({
+    message: entry.message ?? "Validation failed",
+    path: normalizeSuperstructPath(entry)
+  }));
+}
+function normalizeSuperstructPath(failure) {
+  if (failure.path?.length) return [...failure.path];
+  if (typeof failure.key === "string" || typeof failure.key === "number") return [failure.key];
+  return void 0;
+}
+function normalizeVineError(error) {
+  if (!isVineValidationError(error)) {
+    return [{ message: "Validation failed" }];
+  }
+  return error.messages.map((message) => ({
+    message: message.message,
+    path: normalizeVineField(message)
+  }));
+}
+function normalizeVineField(message) {
+  const path = message.field.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+  if (typeof message.index === "number" && path.length === 0) {
+    return [message.index];
+  }
+  return path.length ? path : void 0;
+}
+function parseAjvPath(issue) {
+  const path = issue.instancePath?.split("/").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+  if (issue.params?.missingProperty) {
+    return (path ?? []).concat(issue.params.missingProperty);
+  }
+  return path;
+}
+function parsePathString(path) {
+  if (!path) return void 0;
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+}
+function isYupValidationError(error) {
+  return typeof error === "object" && error !== null && "message" in error;
+}
+function isArkTypeErrors(value) {
+  return Array.isArray(value);
+}
+function isVineValidationError(error) {
+  return typeof error === "object" && error !== null && "messages" in error && Array.isArray(error.messages);
+}
+function formatIssue(issue, key, location = "pointer") {
+  const path = (issue.path ?? []).map(String);
+  const joinedPath = path.join(".");
+  if (location === "parameter") {
+    return {
+      detail: issue.message,
+      parameter: (key ?? joinedPath) || void 0
+    };
+  }
+  return {
+    detail: issue.message,
+    pointer: buildPointer(path)
+  };
+}
+function buildPointer(path) {
+  return path.length === 0 ? "#" : `#/${path.join("/")}`;
+}
+
+// src/validation/model-router.ts
+import { z as z2 } from "zod";
+var listQuerySchema = z2.object({
+  skip: positiveIntegerString.optional(),
+  limit: positiveIntegerString.optional(),
+  page: positiveIntegerString.optional(),
+  page_size: positiveIntegerString.optional(),
+  skim: queryBooleanString.optional(),
+  include_permissions: queryBooleanString.optional(),
+  include_count: queryBooleanString.optional(),
+  include_extra_headers: queryBooleanString.optional()
+}).passthrough();
+var createQuerySchema = z2.object({
+  include_permissions: queryBooleanString.optional()
+}).passthrough();
+var readQuerySchema = z2.object({
+  include_permissions: queryBooleanString.optional(),
+  try_list: queryBooleanString.optional()
+}).passthrough();
+var updateQuerySchema = z2.object({
+  returning_all: queryBooleanString.optional(),
+  include_permissions: queryBooleanString.optional()
+}).passthrough();
+var upsertQuerySchema = z2.object({
+  returning_all: queryBooleanString.optional(),
+  include_permissions: queryBooleanString.optional()
+}).passthrough();
+var listBodySchema = z2.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional(),
+  sort: sortSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional(),
+  skip: z2.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: z2.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: z2.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: z2.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  options: z2.object({
+    skim: z2.boolean().optional(),
+    includePermissions: z2.boolean().optional(),
+    includeCount: z2.boolean().optional(),
+    includeExtraHeaders: z2.boolean().optional(),
+    populateAccess: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["query"]));
+var countBodySchema = z2.object({
+  filter: objectOrArraySchema.optional(),
+  options: z2.object({
+    access: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["query", "access"]));
+var readFilterBodySchema = z2.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional(),
+  sort: sortSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: z2.object({
+    skim: z2.boolean().optional(),
+    includePermissions: z2.boolean().optional(),
+    tryList: z2.boolean().optional(),
+    populateAccess: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var readByIdBodySchema = z2.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: z2.object({
+    skim: z2.boolean().optional(),
+    includePermissions: z2.boolean().optional(),
+    tryList: z2.boolean().optional(),
+    populateAccess: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var advancedCreateBodySchema = z2.object({
+  data: z2.unknown(),
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: z2.object({
+    includePermissions: z2.boolean().optional(),
+    populateAccess: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var createBodySchema = z2.union([
+  z2.record(z2.string(), z2.unknown()),
+  z2.array(z2.record(z2.string(), z2.unknown()))
+]);
+var updateBodySchema = z2.record(z2.string(), z2.unknown());
+var advancedUpdateBodySchema = z2.object({
+  data: z2.unknown(),
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: z2.object({
+    returningAll: z2.boolean().optional(),
+    includePermissions: z2.boolean().optional(),
+    populateAccess: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var upsertBodySchema = z2.record(z2.string(), z2.unknown());
+var advancedUpsertBodySchema = z2.object({
+  data: z2.record(z2.string(), z2.unknown()),
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional(),
+  options: z2.object({
+    returningAll: z2.boolean().optional(),
+    includePermissions: z2.boolean().optional(),
+    populateAccess: z2.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+var distinctBodySchema = z2.object({
+  filter: objectOrArraySchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["query"]));
+var subListBodySchema = z2.object({
+  filter: z2.record(z2.string(), z2.unknown()).optional(),
+  select: fieldsSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["fields"]));
+var subMutationBodySchema = z2.union([
+  z2.record(z2.string(), z2.unknown()),
+  z2.array(z2.record(z2.string(), z2.unknown()))
+]);
+var subReadBodySchema = z2.object({
+  select: fieldsSchema.optional(),
+  populate: subPopulateSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["fields"]));
+var requestSchemas = {
+  listQuery: listQuerySchema,
+  createQuery: createQuerySchema,
+  readQuery: readQuerySchema,
+  updateQuery: updateQuerySchema,
+  upsertQuery: upsertQuerySchema
+};
+
+// src/validation/data-router.ts
+import { z as z3 } from "zod";
+var dataListBodySchema = z3.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional(),
+  sort: z3.string().optional(),
+  skip: z3.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: z3.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: z3.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: z3.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  options: z3.object({
+    includeCount: z3.boolean().optional(),
+    includeExtraHeaders: z3.boolean().optional()
+  }).passthrough().optional()
+}).passthrough();
+var dataReadFilterBodySchema = z3.object({
+  filter: objectOrArraySchema.optional(),
+  select: projectionSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["options"]));
+var dataReadByIdBodySchema = z3.object({
+  select: projectionSchema.optional()
+}).passthrough().superRefine((body, ctx) => rejectKeys(body, ctx, ["options"]));
+
+// src/validation/root-router.ts
+import { z as z4 } from "zod";
+var rootEntryBaseSchema = {
+  target: z4.enum(["model", "data"]),
+  name: z4.string().min(1),
+  order: z4.number().int().optional()
+};
+var rootModelListArgsSchema = z4.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  sort: sortSchema.optional(),
+  skip: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelListOptionsSchema = z4.object({
+  skim: z4.boolean().optional(),
+  includePermissions: z4.boolean().optional(),
+  includeCount: z4.boolean().optional(),
+  populateAccess: z4.unknown().optional(),
+  lean: z4.boolean().optional()
+}).passthrough();
+var rootModelReadArgsSchema = z4.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  include: includeSchema.optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelReadFilterArgsSchema = rootModelReadArgsSchema.extend({
+  sort: sortSchema.optional()
+});
+var rootModelReadOptionsSchema = z4.object({
+  skim: z4.boolean().optional(),
+  includePermissions: z4.boolean().optional(),
+  tryList: z4.boolean().optional(),
+  populateAccess: z4.unknown().optional(),
+  lean: z4.boolean().optional()
+}).passthrough();
+var rootModelCreateArgsSchema = z4.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelCreateOptionsSchema = z4.object({
+  skim: z4.boolean().optional(),
+  includePermissions: z4.boolean().optional(),
+  populateAccess: z4.unknown().optional()
+}).passthrough();
+var rootModelUpdateArgsSchema = z4.object({
+  select: projectionSchema.optional(),
+  populate: populateSchema.optional(),
+  tasks: tasksSchema.optional()
+}).passthrough();
+var rootModelUpdateOptionsSchema = z4.object({
+  skim: z4.boolean().optional(),
+  returningAll: z4.boolean().optional(),
+  includePermissions: z4.boolean().optional(),
+  populateAccess: z4.unknown().optional()
+}).passthrough();
+var rootModelUpsertArgsSchema = rootModelUpdateArgsSchema;
+var rootModelUpsertOptionsSchema = rootModelUpdateOptionsSchema;
+var rootModelSubListArgsSchema = z4.object({
+  select: fieldsSchema.optional()
+}).passthrough();
+var rootModelSubReadArgsSchema = z4.object({
+  select: fieldsSchema.optional(),
+  populate: subPopulateSchema.optional()
+}).passthrough();
+var rootModelCountOptionsSchema = z4.object({
+  access: z4.unknown().optional()
+}).passthrough();
+var rootDataListArgsSchema = z4.object({
+  select: projectionSchema.optional(),
+  sort: z4.string().optional(),
+  skip: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  limit: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  page: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional(),
+  pageSize: z4.union([nonNegativeIntegerSchema, positiveIntegerString]).optional()
+}).passthrough();
+var rootDataListOptionsSchema = z4.object({
+  includeCount: z4.boolean().optional()
+}).passthrough();
+var rootDataReadArgsSchema = z4.object({
+  select: projectionSchema.optional()
+}).passthrough();
+var rootModelQueryEntrySchema = z4.union([
+  z4.object({ ...rootEntryBaseSchema, target: z4.literal("model"), op: z4.literal("new") }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("list"),
+    filter: objectOrArraySchema.optional(),
+    args: rootModelListArgsSchema.optional(),
+    options: rootModelListOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("read"),
+    id: z4.string().min(1),
+    args: rootModelReadArgsSchema.optional(),
+    options: rootModelReadOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("read"),
+    filter: objectOrArraySchema,
+    args: rootModelReadFilterArgsSchema.optional(),
+    options: rootModelReadOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("create"),
+    data: z4.unknown(),
+    args: rootModelCreateArgsSchema.optional(),
+    options: rootModelCreateOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("update"),
+    id: z4.string().min(1),
+    data: z4.unknown(),
+    args: rootModelUpdateArgsSchema.optional(),
+    options: rootModelUpdateOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("upsert"),
+    data: z4.record(z4.string(), z4.unknown()),
+    args: rootModelUpsertArgsSchema.optional(),
+    options: rootModelUpsertOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({ ...rootEntryBaseSchema, target: z4.literal("model"), op: z4.literal("delete"), id: z4.string().min(1) }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("subList"),
+    id: z4.string().min(1),
+    sub: z4.string().min(1),
+    filter: z4.record(z4.string(), z4.unknown()).optional(),
+    args: rootModelSubListArgsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("subRead"),
+    id: z4.string().min(1),
+    sub: z4.string().min(1),
+    subId: z4.string().min(1),
+    args: rootModelSubReadArgsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("subCreate"),
+    id: z4.string().min(1),
+    sub: z4.string().min(1),
+    data: z4.union([z4.record(z4.string(), z4.unknown()), z4.array(z4.record(z4.string(), z4.unknown()))])
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("subUpdate"),
+    id: z4.string().min(1),
+    sub: z4.string().min(1),
+    subId: z4.string().min(1),
+    data: z4.union([z4.record(z4.string(), z4.unknown()), z4.array(z4.record(z4.string(), z4.unknown()))])
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("subBulkUpdate"),
+    id: z4.string().min(1),
+    sub: z4.string().min(1),
+    data: z4.union([z4.record(z4.string(), z4.unknown()), z4.array(z4.record(z4.string(), z4.unknown()))])
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("subDelete"),
+    id: z4.string().min(1),
+    sub: z4.string().min(1),
+    subId: z4.string().min(1)
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("distinct"),
+    field: z4.string().min(1),
+    filter: objectOrArraySchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("model"),
+    op: z4.literal("count"),
+    filter: objectOrArraySchema.optional(),
+    options: rootModelCountOptionsSchema.optional()
+  }).passthrough()
+]);
+var rootDataQueryEntrySchema = z4.union([
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("data"),
+    op: z4.literal("list"),
+    filter: objectOrArraySchema.optional(),
+    args: rootDataListArgsSchema.optional(),
+    options: rootDataListOptionsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("data"),
+    op: z4.literal("read"),
+    id: z4.string().min(1),
+    args: rootDataReadArgsSchema.optional()
+  }).passthrough(),
+  z4.object({
+    ...rootEntryBaseSchema,
+    target: z4.literal("data"),
+    op: z4.literal("read"),
+    filter: objectOrArraySchema,
+    args: rootDataReadArgsSchema.optional()
+  }).passthrough()
+]);
+var rootQuerySchema = z4.array(z4.union([rootModelQueryEntrySchema, rootDataQueryEntrySchema]));
+export {
+  CORE,
+  Codes,
+  CustomHeaders,
+  DATA_MIDDLEWARE,
+  FilterOperator,
+  MIDDLEWARE,
+  PERMISSIONS,
+  PERMISSION_KEYS,
+  StatusCodes,
+  advancedCreateBodySchema,
+  advancedUpdateBodySchema,
+  advancedUpsertBodySchema,
+  countBodySchema,
+  createBodySchema,
+  createQuerySchema,
+  dataListBodySchema,
+  dataReadByIdBodySchema,
+  dataReadFilterBodySchema,
+  defineRequestSchema,
+  distinctBodySchema,
+  fromAjv,
+  fromArkType,
+  fromIoTs,
+  fromJoi,
+  fromStandardSchema,
+  fromSuperstruct,
+  fromValibot,
+  fromVine,
+  fromYup,
+  fromZod,
+  listBodySchema,
+  listQuerySchema,
+  parseBody,
+  parseBodyWithSchema,
+  parseNestedBodyWithSchema,
+  parsePathParam,
+  parseQuery,
+  readByIdBodySchema,
+  readFilterBodySchema,
+  readQuerySchema,
+  requestSchemas,
+  rootQuerySchema,
+  subListBodySchema,
+  subMutationBodySchema,
+  subReadBodySchema,
+  updateBodySchema,
+  updateQuerySchema,
+  upsertBodySchema,
+  upsertQuerySchema
+};