@querykitjs/class-validator 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -1,431 +1,117 @@
 'use strict';
 
-var core = require('@querykitjs/core');
-var classValidator = require('class-validator');
+var chunkBZRPXHJC_cjs = require('./chunk-BZRPXHJC.cjs');
+var chunkX7HMP7H7_cjs = require('./chunk-X7HMP7H7.cjs');
+var chunkKXCJO556_cjs = require('./chunk-KXCJO556.cjs');
 var classTransformer = require('class-transformer');
+var classValidator = require('class-validator');
+var core = require('@querykitjs/core');
 
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-
-// src/locales.ts
-var QUERYKIT_MESSAGES_EN = {
-  "querykit.filter.invalid_node": "{path} must be a filter condition or an and/or/not group",
-  "querykit.filter.missing_key": "{path} is missing the required `key` string",
-  "querykit.filter.unknown_key": "{path}: `{key}` is not an allowed filter key",
-  "querykit.filter.invalid_operator": "{path}: `{operation}` is not a supported filter operator",
-  "querykit.filter.invalid_value": "{path} must be a string, number, boolean, null, or an array of those",
-  "querykit.filter.invalid_group": "{path} must be an array of filter nodes",
-  "querykit.filter.max_depth": "{path} exceeds the maximum filter depth of {max}",
-  "querykit.filter.value_requires_array": "{path}: `{operation}` requires an array value",
-  "querykit.filter.value_requires_tuple": "{path}: `{operation}` requires exactly two values",
-  "querykit.filter.value_forbidden": "{path}: `{operation}` must not carry a value",
-  "querykit.sort.not_array": "{path} must be an array of { key, direction } items",
-  "querykit.sort.invalid_item": "{path} must be an object with a `key` string",
-  "querykit.sort.missing_key": "{path} is missing the required `key` string",
-  "querykit.sort.unknown_key": "{path}: `{key}` is not an allowed sort key",
-  "querykit.sort.invalid_direction": "{path}: direction must be `asc` or `desc`"
-};
-var QUERYKIT_MESSAGES_UZ = {
-  "querykit.filter.invalid_node": "{path} filter sharti yoki and/or/not guruhi bo'lishi kerak",
-  "querykit.filter.missing_key": "{path} da majburiy `key` (string) yo'q",
-  "querykit.filter.unknown_key": "{path}: `{key}` ruxsat etilgan filter kaliti emas",
-  "querykit.filter.invalid_operator": "{path}: `{operation}` qo'llab-quvvatlanadigan filter operatori emas",
-  "querykit.filter.invalid_value": "{path} string, raqam, boolean, null yoki shularning massivi bo'lishi kerak",
-  "querykit.filter.invalid_group": "{path} filter tugunlari massivi bo'lishi kerak",
-  "querykit.filter.max_depth": "{path} ruxsat etilgan filter chuqurligidan ({max}) oshib ketdi",
-  "querykit.filter.value_requires_array": "{path}: `{operation}` massiv qiymat talab qiladi",
-  "querykit.filter.value_requires_tuple": "{path}: `{operation}` aynan ikkita qiymat talab qiladi",
-  "querykit.filter.value_forbidden": "{path}: `{operation}` qiymat qabul qilmaydi",
-  "querykit.sort.not_array": "{path} `{ key, direction }` elementlaridan iborat massiv bo'lishi kerak",
-  "querykit.sort.invalid_item": "{path} `key` (string) maydoniga ega obyekt bo'lishi kerak",
-  "querykit.sort.missing_key": "{path} da majburiy `key` (string) yo'q",
-  "querykit.sort.unknown_key": "{path}: `{key}` ruxsat etilgan sort kaliti emas",
-  "querykit.sort.invalid_direction": "{path}: direction `asc` yoki `desc` bo'lishi kerak"
-};
-var QUERYKIT_MESSAGES_RU = {
-  "querykit.filter.invalid_node": "{path} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0443\u0441\u043B\u043E\u0432\u0438\u0435\u043C \u0444\u0438\u043B\u044C\u0442\u0440\u0430 \u0438\u043B\u0438 \u0433\u0440\u0443\u043F\u043F\u043E\u0439 and/or/not",
-  "querykit.filter.missing_key": "\u0432 {path} \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u043F\u043E\u043B\u0435 `key` (\u0441\u0442\u0440\u043E\u043A\u0430)",
-  "querykit.filter.unknown_key": "{path}: `{key}` \u2014 \u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 \u043A\u043B\u044E\u0447 \u0444\u0438\u043B\u044C\u0442\u0440\u0430",
-  "querykit.filter.invalid_operator": "{path}: `{operation}` \u2014 \u043D\u0435\u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u043C\u044B\u0439 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u0444\u0438\u043B\u044C\u0442\u0440\u0430",
-  "querykit.filter.invalid_value": "{path} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u043E\u0439, \u0447\u0438\u0441\u043B\u043E\u043C, boolean, null \u0438\u043B\u0438 \u043C\u0430\u0441\u0441\u0438\u0432\u043E\u043C \u0438\u0437 \u043D\u0438\u0445",
-  "querykit.filter.invalid_group": "{path} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043C\u0430\u0441\u0441\u0438\u0432\u043E\u043C \u0443\u0437\u043B\u043E\u0432 \u0444\u0438\u043B\u044C\u0442\u0440\u0430",
-  "querykit.filter.max_depth": "{path} \u043F\u0440\u0435\u0432\u044B\u0448\u0430\u0435\u0442 \u043C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0443\u044E \u0433\u043B\u0443\u0431\u0438\u043D\u0443 \u0444\u0438\u043B\u044C\u0442\u0440\u0430 ({max})",
-  "querykit.filter.value_requires_array": "{path}: `{operation}` \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435-\u043C\u0430\u0441\u0441\u0438\u0432",
-  "querykit.filter.value_requires_tuple": "{path}: `{operation}` \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0440\u043E\u0432\u043D\u043E \u0434\u0432\u0430 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F",
-  "querykit.filter.value_forbidden": "{path}: `{operation}` \u043D\u0435 \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435",
-  "querykit.sort.not_array": "{path} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043C\u0430\u0441\u0441\u0438\u0432\u043E\u043C \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432 `{ key, direction }`",
-  "querykit.sort.invalid_item": "{path} \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043E\u0431\u044A\u0435\u043A\u0442\u043E\u043C \u0441 \u043F\u043E\u043B\u0435\u043C `key` (\u0441\u0442\u0440\u043E\u043A\u0430)",
-  "querykit.sort.missing_key": "\u0432 {path} \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u043F\u043E\u043B\u0435 `key` (\u0441\u0442\u0440\u043E\u043A\u0430)",
-  "querykit.sort.unknown_key": "{path}: `{key}` \u2014 \u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 \u043A\u043B\u044E\u0447 \u0441\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u043A\u0438",
-  "querykit.sort.invalid_direction": "{path}: direction \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C `asc` \u0438\u043B\u0438 `desc`"
-};
-var QUERYKIT_LOCALES = {
-  en: QUERYKIT_MESSAGES_EN,
-  uz: QUERYKIT_MESSAGES_UZ,
-  ru: QUERYKIT_MESSAGES_RU
-};
-
-// src/messages.ts
-var PLACEHOLDER = /\{(\w+)\}/g;
-function formatMessage(key, args = {}, catalog = QUERYKIT_MESSAGES_EN) {
-  return catalog[key].replace(PLACEHOLDER, (match, name) => {
-    const value = args[name];
-    return value === void 0 ? match : String(value);
-  });
-}
-function localizeIssue(issue2, catalog) {
-  return formatMessage(issue2.key, issue2.args, catalog);
-}
-var DEFAULT_MAX_FILTER_DEPTH = 5;
-var ALL_OPERATORS = new Set(core.FILTER_OPERATORS);
-var ARRAY_OPERATORS = /* @__PURE__ */ new Set(["in", "notIn"]);
-var TUPLE_OPERATORS = /* @__PURE__ */ new Set(["between", "notBetween"]);
-var NULLARY_OPERATORS = /* @__PURE__ */ new Set(["isNull", "isNotNull"]);
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isScalar = (value) => value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
-var isFilterValue = (value) => Array.isArray(value) ? value.every(isScalar) : isScalar(value);
-var label = (value) => {
-  try {
-    return String(value);
-  } catch {
-    return Object.prototype.toString.call(value);
-  }
-};
-var issue = (key, path, extra = {}) => {
-  const args = { path, ...extra };
-  return { path, key, message: formatMessage(key, args), args };
-};
-function checkCondition(node, path, ctx) {
-  if (!isRecord(node)) {
-    ctx.issues.push(issue("querykit.filter.invalid_node", path));
-    return;
-  }
-  const { key, operation, value } = node;
-  if (typeof key !== "string") {
-    ctx.issues.push(issue("querykit.filter.missing_key", path));
-    return;
-  }
-  if (ctx.allowedKeys && !ctx.allowedKeys.has(key)) {
-    ctx.issues.push(issue("querykit.filter.unknown_key", path, { key }));
-  }
-  let operator;
-  if (operation !== void 0) {
-    if (typeof operation === "string" && ctx.operators.has(operation)) {
-      operator = operation;
-    } else {
-      ctx.issues.push(issue("querykit.filter.invalid_operator", `${path}.operation`, { operation: label(operation) }));
-    }
-  }
-  if (value !== void 0 && !isFilterValue(value)) {
-    ctx.issues.push(issue("querykit.filter.invalid_value", `${path}.value`));
-  }
-  if (ctx.strictValue && operator !== void 0) {
-    checkValueShape(operator, value, path, ctx);
-  }
-}
-function checkValueShape(operator, value, path, ctx) {
-  const valuePath = `${path}.value`;
-  if (ARRAY_OPERATORS.has(operator)) {
-    if (!Array.isArray(value)) {
-      ctx.issues.push(issue("querykit.filter.value_requires_array", valuePath, { operation: operator }));
-    }
-    return;
-  }
-  if (TUPLE_OPERATORS.has(operator)) {
-    if (!Array.isArray(value) || value.length !== 2) {
-      ctx.issues.push(issue("querykit.filter.value_requires_tuple", valuePath, { operation: operator }));
-    }
-    return;
-  }
-  if (NULLARY_OPERATORS.has(operator) && value !== void 0) {
-    ctx.issues.push(issue("querykit.filter.value_forbidden", valuePath, { operation: operator }));
-  }
-}
-function walkGroup(group, depth, path, ctx) {
-  if (!Array.isArray(group)) {
-    ctx.issues.push(issue("querykit.filter.invalid_group", path));
-    return;
-  }
-  group.forEach((child, index) => walkNode(child, depth + 1, `${path}[${index}]`, ctx));
-}
-function walkNode(node, depth, path, ctx) {
-  if (depth > ctx.maxDepth) {
-    ctx.issues.push(issue("querykit.filter.max_depth", path, { max: ctx.maxDepth }));
-    return;
-  }
-  if (!isRecord(node)) {
-    ctx.issues.push(issue("querykit.filter.invalid_node", path));
-    return;
-  }
-  if ("key" in node) {
-    checkCondition(node, path, ctx);
-    return;
-  }
-  if ("and" in node) {
-    walkGroup(node.and, depth, `${path}.and`, ctx);
-    return;
-  }
-  if ("or" in node) {
-    walkGroup(node.or, depth, `${path}.or`, ctx);
-    return;
-  }
-  if ("not" in node) {
-    walkNode(node.not, depth + 1, `${path}.not`, ctx);
-    return;
-  }
-  ctx.issues.push(issue("querykit.filter.missing_key", path));
-}
-function validateFilter(value, options = {}) {
-  if (value === void 0) return [];
-  const root = options.rootPath ?? "filter";
-  const ctx = {
-    issues: [],
-    allowedKeys: options.allowedKeys ? new Set(options.allowedKeys) : void 0,
-    operators: options.allowedOperators ? new Set(options.allowedOperators) : ALL_OPERATORS,
-    maxDepth: options.maxDepth ?? DEFAULT_MAX_FILTER_DEPTH,
-    strictValue: options.strictValue ?? false
-  };
-  if (Array.isArray(value)) {
-    value.forEach((item, index) => checkCondition(item, `${root}[${index}]`, ctx));
-    return ctx.issues;
-  }
-  walkNode(value, 1, root, ctx);
-  return ctx.issues;
-}
-function validateSort(value, options = {}) {
-  if (value === void 0) return [];
-  const root = options.rootPath ?? "sort";
-  if (!Array.isArray(value)) return [issue("querykit.sort.not_array", root)];
-  const allowedKeys = options.allowedKeys ? new Set(options.allowedKeys) : void 0;
-  const issues = [];
-  value.forEach((item, index) => {
-    const path = `${root}[${index}]`;
-    if (!isRecord(item)) {
-      issues.push(issue("querykit.sort.invalid_item", path));
-      return;
-    }
-    const { key, direction } = item;
-    if (typeof key !== "string") {
-      issues.push(issue("querykit.sort.missing_key", path));
-      return;
-    }
-    if (allowedKeys && !allowedKeys.has(key)) {
-      issues.push(issue("querykit.sort.unknown_key", path, { key }));
-    }
-    if (direction !== void 0 && direction !== "asc" && direction !== "desc") {
-      issues.push(issue("querykit.sort.invalid_direction", `${path}.direction`));
-    }
-  });
-  return issues;
-}
-var optionsOf = (args, fallbackPath) => {
-  const given = args?.constraints?.[0] ?? {};
-  return { rootPath: args?.property ?? fallbackPath, ...given };
-};
-var firstMessage = (issues, options, args, fallback) => {
-  const first = issues[0];
-  if (!first) return `${args?.property ?? "value"} ${fallback}`;
-  return options.messageStyle === "key" ? first.key : first.message;
-};
-exports.IsQueryFilterConstraint = class IsQueryFilterConstraint {
-  validate(value, args) {
-    return validateFilter(value, optionsOf(args, "filter")).length === 0;
-  }
-  defaultMessage(args) {
-    const options = optionsOf(args, "filter");
-    return firstMessage(validateFilter(args?.value, options), options, args, "is not a valid querykit filter");
-  }
-};
-exports.IsQueryFilterConstraint = __decorateClass([
-  classValidator.ValidatorConstraint({ name: "isQueryFilter", async: false })
-], exports.IsQueryFilterConstraint);
-exports.IsQuerySortConstraint = class IsQuerySortConstraint {
-  validate(value, args) {
-    return validateSort(value, optionsOf(args, "sort")).length === 0;
-  }
-  defaultMessage(args) {
-    const options = optionsOf(args, "sort");
-    return firstMessage(validateSort(args?.value, options), options, args, "is not a valid querykit sort");
-  }
-};
-exports.IsQuerySortConstraint = __decorateClass([
-  classValidator.ValidatorConstraint({ name: "isQuerySort", async: false })
-], exports.IsQuerySortConstraint);
-function IsQueryFilter(options, validationOptions) {
-  return (target, propertyName) => {
-    classValidator.registerDecorator({
-      target: target.constructor,
-      propertyName,
-      options: validationOptions,
-      constraints: [options],
-      validator: exports.IsQueryFilterConstraint
-    });
-  };
-}
-function IsQuerySort(options, validationOptions) {
-  return (target, propertyName) => {
-    classValidator.registerDecorator({
-      target: target.constructor,
-      propertyName,
-      options: validationOptions,
-      constraints: [options],
-      validator: exports.IsQuerySortConstraint
-    });
-  };
-}
-var BaseParamsDto = class {
-};
-__decorateClass([
-  classValidator.IsOptional(),
-  IsQueryFilter()
-], BaseParamsDto.prototype, "filter", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  IsQuerySort()
-], BaseParamsDto.prototype, "sort", 2);
-var OffsetParamsDto = class extends BaseParamsDto {
-};
-__decorateClass([
-  classValidator.IsOptional(),
-  classTransformer.Type(() => Number),
-  classValidator.IsInt(),
-  classValidator.IsPositive()
-], OffsetParamsDto.prototype, "page", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classTransformer.Type(() => Number),
-  classValidator.IsInt(),
-  classValidator.IsPositive(),
-  classValidator.Max(core.DEFAULT_MAX_PER_PAGE)
-], OffsetParamsDto.prototype, "perPage", 2);
-var InfiniteParamsDto = class extends BaseParamsDto {
-};
-__decorateClass([
-  classValidator.IsOptional(),
-  classTransformer.Type(() => Number),
-  classValidator.IsInt(),
-  classValidator.IsPositive(),
-  classValidator.Max(core.DEFAULT_MAX_LIMIT)
-], InfiniteParamsDto.prototype, "limit", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classTransformer.Type(() => Number),
-  classValidator.IsInt(),
-  classValidator.Min(0)
-], InfiniteParamsDto.prototype, "offset", 2);
-var CursorParamsDto = class {
-};
-__decorateClass([
-  classValidator.IsOptional(),
-  IsQueryFilter()
-], CursorParamsDto.prototype, "filter", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classTransformer.Type(() => Number),
-  classValidator.IsInt(),
-  classValidator.IsPositive(),
-  classValidator.Max(core.DEFAULT_MAX_LIMIT)
-], CursorParamsDto.prototype, "limit", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classValidator.IsString()
-], CursorParamsDto.prototype, "cursor", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classValidator.IsString()
-], CursorParamsDto.prototype, "cursorKey", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classValidator.IsIn(["asc", "desc"])
-], CursorParamsDto.prototype, "order", 2);
-__decorateClass([
-  classValidator.IsOptional(),
-  classValidator.IsIn(["forward", "backward"])
-], CursorParamsDto.prototype, "direction", 2);
 var applyNumber = (proto, property, bounds) => {
-  classValidator.IsOptional()(proto, property);
-  classTransformer.Type(() => Number)(proto, property);
-  classValidator.IsInt()(proto, property);
-  if (bounds.positive) classValidator.IsPositive()(proto, property);
-  if (bounds.min !== void 0) classValidator.Min(bounds.min)(proto, property);
-  if (bounds.max !== void 0 && Number.isFinite(bounds.max)) classValidator.Max(bounds.max)(proto, property);
-};
-var applyServerOwned = (proto, field) => {
-  classValidator.IsOptional()(proto, field);
-  if (field === "withDeleted") classValidator.IsBoolean()(proto, field);
-  else classValidator.IsObject()(proto, field);
-};
-var applyFilterAndSort = (proto, options, withSort) => {
-  classValidator.IsOptional()(proto, "filter");
-  IsQueryFilter({ ...options.filter, allowedKeys: options.filter?.allowedKeys ?? options.allowedKeys })(proto, "filter");
-  if (withSort) {
-    classValidator.IsOptional()(proto, "sort");
-    IsQuerySort({ ...options.sort, allowedKeys: options.sort?.allowedKeys ?? options.allowedKeys })(proto, "sort");
-  }
-  for (const field of options.allow ?? []) applyServerOwned(proto, field);
-};
-var nameClass = (cls, name) => {
-  Object.defineProperty(cls, "name", { value: name, configurable: true });
-  return cls;
-};
+  classValidator.IsOptional()(proto, property), classTransformer.Type(() => Number)(proto, property), classValidator.IsInt()(proto, property), bounds.positive && classValidator.IsPositive()(proto, property), bounds.min !== void 0 && classValidator.Min(bounds.min)(proto, property), bounds.max !== void 0 && Number.isFinite(bounds.max) && classValidator.Max(bounds.max)(proto, property);
+}, applyServerOwned = (proto, field) => {
+  classValidator.IsOptional()(proto, field), field === "withDeleted" ? classValidator.IsBoolean()(proto, field) : classValidator.IsObject()(proto, field);
+}, applyFilterAndSort = (proto, options, limits, withSort) => {
+  classValidator.IsOptional()(proto, "filter"), chunkX7HMP7H7_cjs.IsQueryFilter({ ...limits, ...options.filter, allowedKeys: options.filter?.allowedKeys ?? options.allowedKeys })(proto, "filter"), withSort && (classValidator.IsOptional()(proto, "sort"), chunkX7HMP7H7_cjs.IsQuerySort({ ...limits, ...options.sort, allowedKeys: options.sort?.allowedKeys ?? options.allowedKeys })(proto, "sort"));
+  for (let field of options.allow ?? []) applyServerOwned(proto, field);
+}, nameClass = (cls, name) => (Object.defineProperty(cls, "name", { value: name, configurable: true }), cls);
 function makeOffsetParamsDto(options = {}) {
   class OffsetParams {
   }
-  applyFilterAndSort(OffsetParams.prototype, options, true);
-  applyNumber(OffsetParams.prototype, "page", { positive: true });
-  applyNumber(OffsetParams.prototype, "perPage", { positive: true, max: options.maxPerPage ?? core.DEFAULT_MAX_PER_PAGE });
-  return nameClass(OffsetParams, "OffsetParamsDto");
+  let limits = core.resolveLimits(options.limits);
+  return applyFilterAndSort(OffsetParams.prototype, options, limits, true), applyNumber(OffsetParams.prototype, "page", { positive: true }), chunkX7HMP7H7_cjs.IsWithinMaxOffset({ mode: "page", maxOffset: limits.maxOffset })(OffsetParams.prototype, "page"), applyNumber(OffsetParams.prototype, "perPage", { positive: true, max: options.maxPerPage ?? core.DEFAULT_MAX_PER_PAGE }), classValidator.IsOptional()(OffsetParams.prototype, "withTotal"), classValidator.IsBoolean()(OffsetParams.prototype, "withTotal"), nameClass(OffsetParams, "OffsetParamsDto");
 }
 function makeInfiniteParamsDto(options = {}) {
   class InfiniteParams {
   }
-  applyFilterAndSort(InfiniteParams.prototype, options, true);
-  applyNumber(InfiniteParams.prototype, "limit", { positive: true, max: options.maxLimit ?? core.DEFAULT_MAX_LIMIT });
-  applyNumber(InfiniteParams.prototype, "offset", { min: 0 });
-  return nameClass(InfiniteParams, "InfiniteParamsDto");
+  let limits = core.resolveLimits(options.limits);
+  return applyFilterAndSort(InfiniteParams.prototype, options, limits, true), applyNumber(InfiniteParams.prototype, "limit", { positive: true, max: options.maxLimit ?? core.DEFAULT_MAX_LIMIT }), applyNumber(InfiniteParams.prototype, "offset", { min: 0 }), chunkX7HMP7H7_cjs.IsWithinMaxOffset({ mode: "offset", maxOffset: limits.maxOffset })(InfiniteParams.prototype, "offset"), nameClass(InfiniteParams, "InfiniteParamsDto");
 }
 function makeCursorParamsDto(options = {}) {
   class CursorParams {
   }
-  const proto = CursorParams.prototype;
-  applyFilterAndSort(proto, options, false);
-  applyNumber(proto, "limit", { positive: true, max: options.maxLimit ?? core.DEFAULT_MAX_LIMIT });
-  classValidator.IsOptional()(proto, "cursor");
-  classValidator.IsString()(proto, "cursor");
-  classValidator.IsOptional()(proto, "cursorKey");
-  classValidator.IsString()(proto, "cursorKey");
-  classValidator.IsOptional()(proto, "order");
-  classValidator.IsIn(["asc", "desc"])(proto, "order");
-  classValidator.IsOptional()(proto, "direction");
-  classValidator.IsIn(["forward", "backward"])(proto, "direction");
-  return nameClass(CursorParams, "CursorParamsDto");
+  let proto = CursorParams.prototype;
+  return applyFilterAndSort(proto, options, core.resolveLimits(options.limits), false), applyNumber(proto, "limit", { positive: true, max: options.maxLimit ?? core.DEFAULT_MAX_LIMIT }), classValidator.IsOptional()(proto, "cursor"), classValidator.IsString()(proto, "cursor"), classValidator.IsOptional()(proto, "cursorKey"), classValidator.IsString()(proto, "cursorKey"), classValidator.IsOptional()(proto, "order"), classValidator.IsIn(["asc", "desc"])(proto, "order"), classValidator.IsOptional()(proto, "direction"), classValidator.IsIn(["forward", "backward"])(proto, "direction"), nameClass(CursorParams, "CursorParamsDto");
 }
 
-exports.BaseParamsDto = BaseParamsDto;
-exports.CursorParamsDto = CursorParamsDto;
-exports.DEFAULT_MAX_FILTER_DEPTH = DEFAULT_MAX_FILTER_DEPTH;
-exports.InfiniteParamsDto = InfiniteParamsDto;
-exports.IsQueryFilter = IsQueryFilter;
-exports.IsQuerySort = IsQuerySort;
-exports.OffsetParamsDto = OffsetParamsDto;
-exports.QUERYKIT_LOCALES = QUERYKIT_LOCALES;
-exports.QUERYKIT_MESSAGES_EN = QUERYKIT_MESSAGES_EN;
-exports.QUERYKIT_MESSAGES_RU = QUERYKIT_MESSAGES_RU;
-exports.QUERYKIT_MESSAGES_UZ = QUERYKIT_MESSAGES_UZ;
-exports.formatMessage = formatMessage;
-exports.localizeIssue = localizeIssue;
+Object.defineProperty(exports, "BaseParamsDto", {
+  enumerable: true,
+  get: function () { return chunkBZRPXHJC_cjs.BaseParamsDto; }
+});
+Object.defineProperty(exports, "CursorParamsDto", {
+  enumerable: true,
+  get: function () { return chunkBZRPXHJC_cjs.CursorParamsDto; }
+});
+Object.defineProperty(exports, "InfiniteParamsDto", {
+  enumerable: true,
+  get: function () { return chunkBZRPXHJC_cjs.InfiniteParamsDto; }
+});
+Object.defineProperty(exports, "OffsetParamsDto", {
+  enumerable: true,
+  get: function () { return chunkBZRPXHJC_cjs.OffsetParamsDto; }
+});
+Object.defineProperty(exports, "IsQueryFilter", {
+  enumerable: true,
+  get: function () { return chunkX7HMP7H7_cjs.IsQueryFilter; }
+});
+Object.defineProperty(exports, "IsQueryFilterConstraint", {
+  enumerable: true,
+  get: function () { return chunkX7HMP7H7_cjs.IsQueryFilterConstraint; }
+});
+Object.defineProperty(exports, "IsQuerySort", {
+  enumerable: true,
+  get: function () { return chunkX7HMP7H7_cjs.IsQuerySort; }
+});
+Object.defineProperty(exports, "IsQuerySortConstraint", {
+  enumerable: true,
+  get: function () { return chunkX7HMP7H7_cjs.IsQuerySortConstraint; }
+});
+Object.defineProperty(exports, "IsWithinMaxOffset", {
+  enumerable: true,
+  get: function () { return chunkX7HMP7H7_cjs.IsWithinMaxOffset; }
+});
+Object.defineProperty(exports, "IsWithinMaxOffsetConstraint", {
+  enumerable: true,
+  get: function () { return chunkX7HMP7H7_cjs.IsWithinMaxOffsetConstraint; }
+});
+Object.defineProperty(exports, "DEFAULT_MAX_FILTER_DEPTH", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.DEFAULT_MAX_FILTER_DEPTH; }
+});
+Object.defineProperty(exports, "QUERYKIT_LOCALES", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.QUERYKIT_LOCALES; }
+});
+Object.defineProperty(exports, "QUERYKIT_MESSAGES_EN", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.QUERYKIT_MESSAGES_EN; }
+});
+Object.defineProperty(exports, "QUERYKIT_MESSAGES_RU", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.QUERYKIT_MESSAGES_RU; }
+});
+Object.defineProperty(exports, "QUERYKIT_MESSAGES_UZ", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.QUERYKIT_MESSAGES_UZ; }
+});
+Object.defineProperty(exports, "formatMessage", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.formatMessage; }
+});
+Object.defineProperty(exports, "localizeIssue", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.localizeIssue; }
+});
+Object.defineProperty(exports, "validateFilter", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.validateFilter; }
+});
+Object.defineProperty(exports, "validateSort", {
+  enumerable: true,
+  get: function () { return chunkKXCJO556_cjs.validateSort; }
+});
 exports.makeCursorParamsDto = makeCursorParamsDto;
 exports.makeInfiniteParamsDto = makeInfiniteParamsDto;
 exports.makeOffsetParamsDto = makeOffsetParamsDto;
-exports.validateFilter = validateFilter;
-exports.validateSort = validateSort;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map