@strapi/utils 5.18.1 → 5.20.0

package/dist/index.d.ts

@@ -23,5 +23,6 @@ export * as contentTypes from './content-types';
 export * as relations from './relations';
 export * as hooks from './hooks';
 export * from './zod';
+export * from './validation';
 export * from './primitives';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,cAAc,OAAO,CAAC;AAEtB,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAE7B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -25,6 +25,9 @@ var contentTypes = require('./content-types.js');
 var relations = require('./relations.js');
 var hooks = require('./hooks.js');
 var zod = require('./zod.js');
+var base = require('./validation/route-validators/base.js');
+var queryParams = require('./validation/route-validators/query-params.js');
+var utilities = require('./validation/utilities.js');
 var strings = require('./primitives/strings.js');
 var arrays = require('./primitives/arrays.js');
 var objects = require('./primitives/objects.js');
@@ -59,6 +62,22 @@ exports.contentTypes = contentTypes;
 exports.relations = relations;
 exports.hooks = hooks;
 exports.validateZod = zod.validateZod;
+exports.AbstractRouteValidator = base.AbstractRouteValidator;
+exports.filtersSchema = queryParams.filtersSchema;
+exports.localeSchema = queryParams.localeSchema;
+exports.paginationSchema = queryParams.paginationSchema;
+exports.queryFieldsSchema = queryParams.queryFieldsSchema;
+exports.queryParameterSchemas = queryParams.queryParameterSchemas;
+exports.queryPopulateSchema = queryParams.queryPopulateSchema;
+exports.querySortSchema = queryParams.querySortSchema;
+exports.searchQuerySchema = queryParams.searchQuerySchema;
+exports.statusSchema = queryParams.statusSchema;
+exports.augmentSchema = utilities.augmentSchema;
+exports.maybeReadonly = utilities.maybeReadonly;
+exports.maybeRequired = utilities.maybeRequired;
+exports.maybeWithDefault = utilities.maybeWithDefault;
+exports.maybeWithMinMax = utilities.maybeWithMinMax;
+exports.transformUidToValidOpenApiName = utilities.transformUidToValidOpenApiName;
 exports.strings = strings;
 exports.arrays = arrays;
 exports.objects = objects;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -38,6 +38,9 @@ export { relations };
 import * as hooks from './hooks.mjs';
 export { hooks };
 export { validateZod } from './zod.mjs';
+export { AbstractRouteValidator } from './validation/route-validators/base.mjs';
+export { filtersSchema, localeSchema, paginationSchema, queryFieldsSchema, queryParameterSchemas, queryPopulateSchema, querySortSchema, searchQuerySchema, statusSchema } from './validation/route-validators/query-params.mjs';
+export { augmentSchema, maybeReadonly, maybeRequired, maybeWithDefault, maybeWithMinMax, transformUidToValidOpenApiName } from './validation/utilities.mjs';
 import * as strings from './primitives/strings.mjs';
 export { strings };
 import * as arrays from './primitives/arrays.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './route-validators';
+export * from './utilities';
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC"}

package/dist/validation/route-validators/base.d.ts

@@ -0,0 +1,107 @@
+import * as z from 'zod/v4';
+import { type QueryParam } from './query-params';
+/**
+ * AbstractRouteValidator provides the foundation for validating routes.
+ *
+ * This abstract class provides common query parameter validators that can be reused
+ * across different route validators in Strapi. It serves as a building block for
+ * both generic validation (plugins, external packages) and schema-aware validation
+ * (core content types).
+ */
+export declare abstract class AbstractRouteValidator {
+    /**
+     * Creates a fields query parameter validator
+     * Validates field selection for API responses
+     */
+    get queryFields(): z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    /**
+     * Creates a populate query parameter validator
+     * Validates which relations to populate in the response
+     */
+    get queryPopulate(): z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    /**
+     * Creates a sort query parameter validator
+     * Validates sorting options for list endpoints
+     */
+    get querySort(): z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>>]>;
+    /**
+     * Creates a pagination query parameter validator
+     * Supports both page-based and offset-based pagination
+     */
+    get pagination(): z.ZodIntersection<z.ZodObject<{
+        withCount: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        start: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    /**
+     * Creates a filters query parameter validator
+     * Validates filtering options for list endpoints
+     */
+    get filters(): z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * Creates a locale query parameter validator
+     * Used for internationalization
+     */
+    get locale(): z.ZodString;
+    /**
+     * Creates a status query parameter validator
+     * Used for draft & publish functionality
+     */
+    get status(): z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>;
+    /**
+     * Creates a search query parameter validator
+     * Used for text search functionality
+     */
+    get query(): z.ZodString;
+    /**
+     * Provides access to all base query parameter validators
+     */
+    protected get baseQueryValidators(): {
+        fields: () => z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        populate: () => z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+        sort: () => z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>>]>>;
+        filters: () => z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        pagination: () => z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+            withCount: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+            page: z.ZodNumber;
+            pageSize: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            start: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>]>>>;
+        locale: () => z.ZodOptional<z.ZodString>;
+        status: () => z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            published: "published";
+        }>>;
+        _q: () => z.ZodOptional<z.ZodString>;
+    };
+    /**
+     * Helper method to create a query parameters object with specified validators
+     *
+     * @param params - Array of query parameter names to include
+     * @returns Object containing Zod schemas for the requested query parameters
+     */
+    queryParams(params: QueryParam[]): Record<string, z.ZodSchema>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/validation/route-validators/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/validation/route-validators/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAyB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExE;;;;;;;GAOG;AACH,8BAAsB,sBAAsB;IAC1C;;;OAGG;IACH,IAAI,WAAW,gEAEd;IAED;;;OAGG;IACH,IAAI,aAAa,uHAEhB;IAED;;;OAGG;IACH,IAAI,SAAS;;;;;;WAEZ;IAED;;;OAGG;IACH,IAAI,UAAU;;;;;;;;yBAEb;IAED;;;OAGG;IACH,IAAI,OAAO,uCAEV;IAED;;;OAGG;IACH,IAAI,MAAM,gBAET;IAED;;;OAGG;IACH,IAAI,MAAM;;;OAET;IAED;;;OAGG;IACH,IAAI,KAAK,gBAER;IAED;;OAEG;IACH,SAAS,KAAK,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;MAWhC;IAED;;;;;OAKG;IACH,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC;CAa/D"}

package/dist/validation/route-validators/base.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var queryParams = require('./query-params.js');
+
+/**
+ * AbstractRouteValidator provides the foundation for validating routes.
+ *
+ * This abstract class provides common query parameter validators that can be reused
+ * across different route validators in Strapi. It serves as a building block for
+ * both generic validation (plugins, external packages) and schema-aware validation
+ * (core content types).
+ */ class AbstractRouteValidator {
+    /**
+   * Creates a fields query parameter validator
+   * Validates field selection for API responses
+   */ get queryFields() {
+        return queryParams.queryParameterSchemas.fields;
+    }
+    /**
+   * Creates a populate query parameter validator
+   * Validates which relations to populate in the response
+   */ get queryPopulate() {
+        return queryParams.queryParameterSchemas.populate;
+    }
+    /**
+   * Creates a sort query parameter validator
+   * Validates sorting options for list endpoints
+   */ get querySort() {
+        return queryParams.queryParameterSchemas.sort;
+    }
+    /**
+   * Creates a pagination query parameter validator
+   * Supports both page-based and offset-based pagination
+   */ get pagination() {
+        return queryParams.queryParameterSchemas.pagination;
+    }
+    /**
+   * Creates a filters query parameter validator
+   * Validates filtering options for list endpoints
+   */ get filters() {
+        return queryParams.queryParameterSchemas.filters;
+    }
+    /**
+   * Creates a locale query parameter validator
+   * Used for internationalization
+   */ get locale() {
+        return queryParams.queryParameterSchemas.locale;
+    }
+    /**
+   * Creates a status query parameter validator
+   * Used for draft & publish functionality
+   */ get status() {
+        return queryParams.queryParameterSchemas.status;
+    }
+    /**
+   * Creates a search query parameter validator
+   * Used for text search functionality
+   */ get query() {
+        return queryParams.queryParameterSchemas._q;
+    }
+    /**
+   * Provides access to all base query parameter validators
+   */ get baseQueryValidators() {
+        return {
+            fields: ()=>this.queryFields.optional(),
+            populate: ()=>this.queryPopulate.optional(),
+            sort: ()=>this.querySort.optional(),
+            filters: ()=>this.filters.optional(),
+            pagination: ()=>this.pagination.optional(),
+            locale: ()=>this.locale.optional(),
+            status: ()=>this.status.optional(),
+            _q: ()=>this.query.optional()
+        };
+    }
+    /**
+   * Helper method to create a query parameters object with specified validators
+   *
+   * @param params - Array of query parameter names to include
+   * @returns Object containing Zod schemas for the requested query parameters
+   */ queryParams(params) {
+        const validators = this.baseQueryValidators;
+        return params.reduce((acc, param)=>{
+            if (param in validators) {
+                acc[param] = validators[param]();
+            }
+            return acc;
+        }, {});
+    }
+}
+
+exports.AbstractRouteValidator = AbstractRouteValidator;
+//# sourceMappingURL=base.js.map

package/dist/validation/route-validators/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../../src/validation/route-validators/base.ts"],"sourcesContent":["import * as z from 'zod/v4';\nimport { queryParameterSchemas, type QueryParam } from './query-params';\n\n/**\n * AbstractRouteValidator provides the foundation for validating routes.\n *\n * This abstract class provides common query parameter validators that can be reused\n * across different route validators in Strapi. It serves as a building block for\n * both generic validation (plugins, external packages) and schema-aware validation\n * (core content types).\n */\nexport abstract class AbstractRouteValidator {\n  /**\n   * Creates a fields query parameter validator\n   * Validates field selection for API responses\n   */\n  get queryFields() {\n    return queryParameterSchemas.fields;\n  }\n\n  /**\n   * Creates a populate query parameter validator\n   * Validates which relations to populate in the response\n   */\n  get queryPopulate() {\n    return queryParameterSchemas.populate;\n  }\n\n  /**\n   * Creates a sort query parameter validator\n   * Validates sorting options for list endpoints\n   */\n  get querySort() {\n    return queryParameterSchemas.sort;\n  }\n\n  /**\n   * Creates a pagination query parameter validator\n   * Supports both page-based and offset-based pagination\n   */\n  get pagination() {\n    return queryParameterSchemas.pagination;\n  }\n\n  /**\n   * Creates a filters query parameter validator\n   * Validates filtering options for list endpoints\n   */\n  get filters() {\n    return queryParameterSchemas.filters;\n  }\n\n  /**\n   * Creates a locale query parameter validator\n   * Used for internationalization\n   */\n  get locale() {\n    return queryParameterSchemas.locale;\n  }\n\n  /**\n   * Creates a status query parameter validator\n   * Used for draft & publish functionality\n   */\n  get status() {\n    return queryParameterSchemas.status;\n  }\n\n  /**\n   * Creates a search query parameter validator\n   * Used for text search functionality\n   */\n  get query() {\n    return queryParameterSchemas._q;\n  }\n\n  /**\n   * Provides access to all base query parameter validators\n   */\n  protected get baseQueryValidators() {\n    return {\n      fields: () => this.queryFields.optional(),\n      populate: () => this.queryPopulate.optional(),\n      sort: () => this.querySort.optional(),\n      filters: () => this.filters.optional(),\n      pagination: () => this.pagination.optional(),\n      locale: () => this.locale.optional(),\n      status: () => this.status.optional(),\n      _q: () => this.query.optional(),\n    };\n  }\n\n  /**\n   * Helper method to create a query parameters object with specified validators\n   *\n   * @param params - Array of query parameter names to include\n   * @returns Object containing Zod schemas for the requested query parameters\n   */\n  queryParams(params: QueryParam[]): Record<string, z.ZodSchema> {\n    const validators = this.baseQueryValidators;\n\n    return params.reduce(\n      (acc, param) => {\n        if (param in validators) {\n          acc[param] = validators[param]();\n        }\n        return acc;\n      },\n      {} as Record<string, z.ZodSchema>\n    );\n  }\n}\n"],"names":["AbstractRouteValidator","queryFields","queryParameterSchemas","fields","queryPopulate","populate","querySort","sort","pagination","filters","locale","status","query","_q","baseQueryValidators","optional","queryParams","params","validators","reduce","acc","param"],"mappings":";;;;AAGA;;;;;;;AAOC,IACM,MAAeA,sBAAAA,CAAAA;AACpB;;;AAGC,MACD,IAAIC,WAAc,GAAA;AAChB,QAAA,OAAOC,kCAAsBC,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,aAAgB,GAAA;AAClB,QAAA,OAAOF,kCAAsBG,QAAQ;AACvC;AAEA;;;AAGC,MACD,IAAIC,SAAY,GAAA;AACd,QAAA,OAAOJ,kCAAsBK,IAAI;AACnC;AAEA;;;AAGC,MACD,IAAIC,UAAa,GAAA;AACf,QAAA,OAAON,kCAAsBM,UAAU;AACzC;AAEA;;;AAGC,MACD,IAAIC,OAAU,GAAA;AACZ,QAAA,OAAOP,kCAAsBO,OAAO;AACtC;AAEA;;;AAGC,MACD,IAAIC,MAAS,GAAA;AACX,QAAA,OAAOR,kCAAsBQ,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,MAAS,GAAA;AACX,QAAA,OAAOT,kCAAsBS,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,KAAQ,GAAA;AACV,QAAA,OAAOV,kCAAsBW,EAAE;AACjC;AAEA;;AAEC,MACD,IAAcC,mBAAsB,GAAA;QAClC,OAAO;AACLX,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACF,WAAW,CAACc,QAAQ,EAAA;AACvCV,YAAAA,QAAAA,EAAU,IAAM,IAAI,CAACD,aAAa,CAACW,QAAQ,EAAA;AAC3CR,YAAAA,IAAAA,EAAM,IAAM,IAAI,CAACD,SAAS,CAACS,QAAQ,EAAA;AACnCN,YAAAA,OAAAA,EAAS,IAAM,IAAI,CAACA,OAAO,CAACM,QAAQ,EAAA;AACpCP,YAAAA,UAAAA,EAAY,IAAM,IAAI,CAACA,UAAU,CAACO,QAAQ,EAAA;AAC1CL,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACA,MAAM,CAACK,QAAQ,EAAA;AAClCJ,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACA,MAAM,CAACI,QAAQ,EAAA;AAClCF,YAAAA,EAAAA,EAAI,IAAM,IAAI,CAACD,KAAK,CAACG,QAAQ;AAC/B,SAAA;AACF;AAEA;;;;;MAMAC,WAAAA,CAAYC,MAAoB,EAA+B;QAC7D,MAAMC,UAAAA,GAAa,IAAI,CAACJ,mBAAmB;AAE3C,QAAA,OAAOG,MAAOE,CAAAA,MAAM,CAClB,CAACC,GAAKC,EAAAA,KAAAA,GAAAA;AACJ,YAAA,IAAIA,SAASH,UAAY,EAAA;AACvBE,gBAAAA,GAAG,CAACC,KAAAA,CAAM,GAAGH,UAAU,CAACG,KAAM,CAAA,EAAA;AAChC;YACA,OAAOD,GAAAA;AACT,SAAA,EACA,EAAC,CAAA;AAEL;AACF;;;;"}

package/dist/validation/route-validators/base.mjs

@@ -0,0 +1,90 @@
+import { queryParameterSchemas } from './query-params.mjs';
+
+/**
+ * AbstractRouteValidator provides the foundation for validating routes.
+ *
+ * This abstract class provides common query parameter validators that can be reused
+ * across different route validators in Strapi. It serves as a building block for
+ * both generic validation (plugins, external packages) and schema-aware validation
+ * (core content types).
+ */ class AbstractRouteValidator {
+    /**
+   * Creates a fields query parameter validator
+   * Validates field selection for API responses
+   */ get queryFields() {
+        return queryParameterSchemas.fields;
+    }
+    /**
+   * Creates a populate query parameter validator
+   * Validates which relations to populate in the response
+   */ get queryPopulate() {
+        return queryParameterSchemas.populate;
+    }
+    /**
+   * Creates a sort query parameter validator
+   * Validates sorting options for list endpoints
+   */ get querySort() {
+        return queryParameterSchemas.sort;
+    }
+    /**
+   * Creates a pagination query parameter validator
+   * Supports both page-based and offset-based pagination
+   */ get pagination() {
+        return queryParameterSchemas.pagination;
+    }
+    /**
+   * Creates a filters query parameter validator
+   * Validates filtering options for list endpoints
+   */ get filters() {
+        return queryParameterSchemas.filters;
+    }
+    /**
+   * Creates a locale query parameter validator
+   * Used for internationalization
+   */ get locale() {
+        return queryParameterSchemas.locale;
+    }
+    /**
+   * Creates a status query parameter validator
+   * Used for draft & publish functionality
+   */ get status() {
+        return queryParameterSchemas.status;
+    }
+    /**
+   * Creates a search query parameter validator
+   * Used for text search functionality
+   */ get query() {
+        return queryParameterSchemas._q;
+    }
+    /**
+   * Provides access to all base query parameter validators
+   */ get baseQueryValidators() {
+        return {
+            fields: ()=>this.queryFields.optional(),
+            populate: ()=>this.queryPopulate.optional(),
+            sort: ()=>this.querySort.optional(),
+            filters: ()=>this.filters.optional(),
+            pagination: ()=>this.pagination.optional(),
+            locale: ()=>this.locale.optional(),
+            status: ()=>this.status.optional(),
+            _q: ()=>this.query.optional()
+        };
+    }
+    /**
+   * Helper method to create a query parameters object with specified validators
+   *
+   * @param params - Array of query parameter names to include
+   * @returns Object containing Zod schemas for the requested query parameters
+   */ queryParams(params) {
+        const validators = this.baseQueryValidators;
+        return params.reduce((acc, param)=>{
+            if (param in validators) {
+                acc[param] = validators[param]();
+            }
+            return acc;
+        }, {});
+    }
+}
+
+export { AbstractRouteValidator };
+//# sourceMappingURL=base.mjs.map

package/dist/validation/route-validators/base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.mjs","sources":["../../../src/validation/route-validators/base.ts"],"sourcesContent":["import * as z from 'zod/v4';\nimport { queryParameterSchemas, type QueryParam } from './query-params';\n\n/**\n * AbstractRouteValidator provides the foundation for validating routes.\n *\n * This abstract class provides common query parameter validators that can be reused\n * across different route validators in Strapi. It serves as a building block for\n * both generic validation (plugins, external packages) and schema-aware validation\n * (core content types).\n */\nexport abstract class AbstractRouteValidator {\n  /**\n   * Creates a fields query parameter validator\n   * Validates field selection for API responses\n   */\n  get queryFields() {\n    return queryParameterSchemas.fields;\n  }\n\n  /**\n   * Creates a populate query parameter validator\n   * Validates which relations to populate in the response\n   */\n  get queryPopulate() {\n    return queryParameterSchemas.populate;\n  }\n\n  /**\n   * Creates a sort query parameter validator\n   * Validates sorting options for list endpoints\n   */\n  get querySort() {\n    return queryParameterSchemas.sort;\n  }\n\n  /**\n   * Creates a pagination query parameter validator\n   * Supports both page-based and offset-based pagination\n   */\n  get pagination() {\n    return queryParameterSchemas.pagination;\n  }\n\n  /**\n   * Creates a filters query parameter validator\n   * Validates filtering options for list endpoints\n   */\n  get filters() {\n    return queryParameterSchemas.filters;\n  }\n\n  /**\n   * Creates a locale query parameter validator\n   * Used for internationalization\n   */\n  get locale() {\n    return queryParameterSchemas.locale;\n  }\n\n  /**\n   * Creates a status query parameter validator\n   * Used for draft & publish functionality\n   */\n  get status() {\n    return queryParameterSchemas.status;\n  }\n\n  /**\n   * Creates a search query parameter validator\n   * Used for text search functionality\n   */\n  get query() {\n    return queryParameterSchemas._q;\n  }\n\n  /**\n   * Provides access to all base query parameter validators\n   */\n  protected get baseQueryValidators() {\n    return {\n      fields: () => this.queryFields.optional(),\n      populate: () => this.queryPopulate.optional(),\n      sort: () => this.querySort.optional(),\n      filters: () => this.filters.optional(),\n      pagination: () => this.pagination.optional(),\n      locale: () => this.locale.optional(),\n      status: () => this.status.optional(),\n      _q: () => this.query.optional(),\n    };\n  }\n\n  /**\n   * Helper method to create a query parameters object with specified validators\n   *\n   * @param params - Array of query parameter names to include\n   * @returns Object containing Zod schemas for the requested query parameters\n   */\n  queryParams(params: QueryParam[]): Record<string, z.ZodSchema> {\n    const validators = this.baseQueryValidators;\n\n    return params.reduce(\n      (acc, param) => {\n        if (param in validators) {\n          acc[param] = validators[param]();\n        }\n        return acc;\n      },\n      {} as Record<string, z.ZodSchema>\n    );\n  }\n}\n"],"names":["AbstractRouteValidator","queryFields","queryParameterSchemas","fields","queryPopulate","populate","querySort","sort","pagination","filters","locale","status","query","_q","baseQueryValidators","optional","queryParams","params","validators","reduce","acc","param"],"mappings":";;AAGA;;;;;;;AAOC,IACM,MAAeA,sBAAAA,CAAAA;AACpB;;;AAGC,MACD,IAAIC,WAAc,GAAA;AAChB,QAAA,OAAOC,sBAAsBC,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,aAAgB,GAAA;AAClB,QAAA,OAAOF,sBAAsBG,QAAQ;AACvC;AAEA;;;AAGC,MACD,IAAIC,SAAY,GAAA;AACd,QAAA,OAAOJ,sBAAsBK,IAAI;AACnC;AAEA;;;AAGC,MACD,IAAIC,UAAa,GAAA;AACf,QAAA,OAAON,sBAAsBM,UAAU;AACzC;AAEA;;;AAGC,MACD,IAAIC,OAAU,GAAA;AACZ,QAAA,OAAOP,sBAAsBO,OAAO;AACtC;AAEA;;;AAGC,MACD,IAAIC,MAAS,GAAA;AACX,QAAA,OAAOR,sBAAsBQ,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,MAAS,GAAA;AACX,QAAA,OAAOT,sBAAsBS,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,KAAQ,GAAA;AACV,QAAA,OAAOV,sBAAsBW,EAAE;AACjC;AAEA;;AAEC,MACD,IAAcC,mBAAsB,GAAA;QAClC,OAAO;AACLX,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACF,WAAW,CAACc,QAAQ,EAAA;AACvCV,YAAAA,QAAAA,EAAU,IAAM,IAAI,CAACD,aAAa,CAACW,QAAQ,EAAA;AAC3CR,YAAAA,IAAAA,EAAM,IAAM,IAAI,CAACD,SAAS,CAACS,QAAQ,EAAA;AACnCN,YAAAA,OAAAA,EAAS,IAAM,IAAI,CAACA,OAAO,CAACM,QAAQ,EAAA;AACpCP,YAAAA,UAAAA,EAAY,IAAM,IAAI,CAACA,UAAU,CAACO,QAAQ,EAAA;AAC1CL,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACA,MAAM,CAACK,QAAQ,EAAA;AAClCJ,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACA,MAAM,CAACI,QAAQ,EAAA;AAClCF,YAAAA,EAAAA,EAAI,IAAM,IAAI,CAACD,KAAK,CAACG,QAAQ;AAC/B,SAAA;AACF;AAEA;;;;;MAMAC,WAAAA,CAAYC,MAAoB,EAA+B;QAC7D,MAAMC,UAAAA,GAAa,IAAI,CAACJ,mBAAmB;AAE3C,QAAA,OAAOG,MAAOE,CAAAA,MAAM,CAClB,CAACC,GAAKC,EAAAA,KAAAA,GAAAA;AACJ,YAAA,IAAIA,SAASH,UAAY,EAAA;AACvBE,gBAAAA,GAAG,CAACC,KAAAA,CAAM,GAAGH,UAAU,CAACG,KAAM,CAAA,EAAA;AAChC;YACA,OAAOD,GAAAA;AACT,SAAA,EACA,EAAC,CAAA;AAEL;AACF;;;;"}

package/dist/validation/route-validators/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Route validation utilities for Strapi
+ *
+ * This module provides route validation that can be used across different
+ * packages & plugins.
+ *
+ * The utilities are designed to work both standalone (for generic validation) and
+ * as building blocks for more sophisticated schema-aware validation via @strapi/core.
+ *
+ * @example
+ * ```typescript
+ * import { AbstractRouteValidator, type QueryParam } from '@strapi/utils';
+ * import * as z from 'zod/v4';
+ *
+ * export class MyPluginRouteValidator extends AbstractRouteValidator {
+ *   constructor(strapi: Core.Strapi) {
+ *     super();
+ *   }
+ *
+ *   // Add custom validators for your plugin
+ *   get myEntity() {
+ *     return z.object({
+ *       id: z.number(),
+ *       name: z.string(),
+ *       // ... other fields
+ *     });
+ *   }
+ *
+ *   // Use inherited query parameter validators
+ *   // In your routes:
+ *   // request: {
+ *   //   query: validator.queryParams(['fields', 'populate', 'sort', 'pagination'])
+ *   // }
+ * }
+ * ```
+ */
+export { AbstractRouteValidator } from './base';
+export * from './query-params';
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/route-validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/validation/route-validators/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAChD,cAAc,gBAAgB,CAAC"}

package/dist/validation/route-validators/query-params.d.ts

@@ -0,0 +1,100 @@
+import * as z from 'zod/v4';
+/**
+ * Standard query parameter validators that can be reused across different route validators
+ *
+ * These schemas provide the basic structure validation for common Strapi API query parameters.
+ * They can be used as building blocks for both generic validation and schema-aware validation.
+ */
+/**
+ * Fields parameter validation
+ * Supports: 'title', ['title', 'name'], or '*'
+ */
+export declare const queryFieldsSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+/**
+ * Populate parameter validation
+ * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects
+ */
+export declare const queryPopulateSchema: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+/**
+ * Sort parameter validation
+ * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]
+ */
+export declare const querySortSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>>>]>;
+/**
+ * Pagination parameter validation
+ * Supports both page-based and offset-based pagination
+ */
+export declare const paginationSchema: z.ZodIntersection<z.ZodObject<{
+    withCount: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    start: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strip>]>>;
+/**
+ * Filters parameter validation
+ * Supports any object structure for filtering
+ */
+export declare const filtersSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+/**
+ * Locale parameter validation
+ * Used for internationalization
+ */
+export declare const localeSchema: z.ZodString;
+/**
+ * Status parameter validation
+ * Used for draft & publish functionality
+ */
+export declare const statusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+}>;
+/**
+ * Search query parameter validation
+ * Used for text search functionality
+ */
+export declare const searchQuerySchema: z.ZodString;
+/**
+ * Complete collection of all standard query parameter schemas
+ * This object provides easy access to all available query parameter validators
+ */
+export declare const queryParameterSchemas: {
+    readonly fields: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    readonly populate: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    readonly sort: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>>]>;
+    readonly pagination: z.ZodIntersection<z.ZodObject<{
+        withCount: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        start: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    readonly filters: z.ZodRecord<z.ZodString, z.ZodAny>;
+    readonly locale: z.ZodString;
+    readonly status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>;
+    readonly _q: z.ZodString;
+};
+/**
+ * Query parameter names supported by Strapi's API
+ */
+export type QueryParam = keyof typeof queryParameterSchemas;
+//# sourceMappingURL=query-params.d.ts.map

package/dist/validation/route-validators/query-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.d.ts","sourceRoot":"","sources":["../../../src/validation/route-validators/query-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,6DAEiC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,oHAEkC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;MAOuB,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;oBAoBO,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,aAAa,oCAAuE,CAAC;AAElG;;;GAGG;AACH,eAAO,MAAM,YAAY,aAAkE,CAAC;AAE5F;;;GAGG;AACH,eAAO,MAAM,YAAY;;;EAA0E,CAAC;AAEpG;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAA6C,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;CASxB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,qBAAqB,CAAC"}

package/dist/validation/route-validators/query-params.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var z = require('zod/v4');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+/**
+ * Standard query parameter validators that can be reused across different route validators
+ *
+ * These schemas provide the basic structure validation for common Strapi API query parameters.
+ * They can be used as building blocks for both generic validation and schema-aware validation.
+ */ /**
+ * Fields parameter validation
+ * Supports: 'title', ['title', 'name'], or '*'
+ */ const queryFieldsSchema = z__namespace.union([
+    z__namespace.string(),
+    z__namespace.array(z__namespace.string())
+]).describe('Select specific fields to return in the response');
+/**
+ * Populate parameter validation
+ * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects
+ */ const queryPopulateSchema = z__namespace.union([
+    z__namespace.literal('*'),
+    z__namespace.string(),
+    z__namespace.array(z__namespace.string()),
+    z__namespace.record(z__namespace.string(), z__namespace.any())
+]).describe('Specify which relations to populate in the response');
+/**
+ * Sort parameter validation
+ * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]
+ */ const querySortSchema = z__namespace.union([
+    z__namespace.string(),
+    z__namespace.array(z__namespace.string()),
+    z__namespace.record(z__namespace.string(), z__namespace.enum([
+        'asc',
+        'desc'
+    ])),
+    z__namespace.array(z__namespace.record(z__namespace.string(), z__namespace.enum([
+        'asc',
+        'desc'
+    ])))
+]).describe('Sort the results by specified fields');
+/**
+ * Pagination parameter validation
+ * Supports both page-based and offset-based pagination
+ */ const paginationSchema = z__namespace.intersection(z__namespace.object({
+    withCount: z__namespace.boolean().optional().describe('Include total count in response')
+}), z__namespace.union([
+    z__namespace.object({
+        page: z__namespace.number().int().positive().describe('Page number (1-based)'),
+        pageSize: z__namespace.number().int().positive().describe('Number of entries per page')
+    }).describe('Page-based pagination'),
+    z__namespace.object({
+        start: z__namespace.number().int().min(0).describe('Number of entries to skip'),
+        limit: z__namespace.number().int().positive().describe('Maximum number of entries to return')
+    }).describe('Offset-based pagination')
+])).describe('Pagination parameters');
+/**
+ * Filters parameter validation
+ * Supports any object structure for filtering
+ */ const filtersSchema = z__namespace.record(z__namespace.string(), z__namespace.any()).describe('Apply filters to the query');
+/**
+ * Locale parameter validation
+ * Used for internationalization
+ */ const localeSchema = z__namespace.string().describe('Specify the locale for localized content');
+/**
+ * Status parameter validation
+ * Used for draft & publish functionality
+ */ const statusSchema = z__namespace.enum([
+    'draft',
+    'published'
+]).describe('Filter by publication status');
+/**
+ * Search query parameter validation
+ * Used for text search functionality
+ */ const searchQuerySchema = z__namespace.string().describe('Search query string');
+/**
+ * Complete collection of all standard query parameter schemas
+ * This object provides easy access to all available query parameter validators
+ */ const queryParameterSchemas = {
+    fields: queryFieldsSchema,
+    populate: queryPopulateSchema,
+    sort: querySortSchema,
+    pagination: paginationSchema,
+    filters: filtersSchema,
+    locale: localeSchema,
+    status: statusSchema,
+    _q: searchQuerySchema
+};
+
+exports.filtersSchema = filtersSchema;
+exports.localeSchema = localeSchema;
+exports.paginationSchema = paginationSchema;
+exports.queryFieldsSchema = queryFieldsSchema;
+exports.queryParameterSchemas = queryParameterSchemas;
+exports.queryPopulateSchema = queryPopulateSchema;
+exports.querySortSchema = querySortSchema;
+exports.searchQuerySchema = searchQuerySchema;
+exports.statusSchema = statusSchema;
+//# sourceMappingURL=query-params.js.map

package/dist/validation/route-validators/query-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.js","sources":["../../../src/validation/route-validators/query-params.ts"],"sourcesContent":["import * as z from 'zod/v4';\n\n/**\n * Standard query parameter validators that can be reused across different route validators\n *\n * These schemas provide the basic structure validation for common Strapi API query parameters.\n * They can be used as building blocks for both generic validation and schema-aware validation.\n */\n\n/**\n * Fields parameter validation\n * Supports: 'title', ['title', 'name'], or '*'\n */\nexport const queryFieldsSchema = z\n  .union([z.string(), z.array(z.string())])\n  .describe('Select specific fields to return in the response');\n\n/**\n * Populate parameter validation\n * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects\n */\nexport const queryPopulateSchema = z\n  .union([z.literal('*'), z.string(), z.array(z.string()), z.record(z.string(), z.any())])\n  .describe('Specify which relations to populate in the response');\n\n/**\n * Sort parameter validation\n * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]\n */\nexport const querySortSchema = z\n  .union([\n    z.string(),\n    z.array(z.string()),\n    z.record(z.string(), z.enum(['asc', 'desc'])),\n    z.array(z.record(z.string(), z.enum(['asc', 'desc']))),\n  ])\n  .describe('Sort the results by specified fields');\n\n/**\n * Pagination parameter validation\n * Supports both page-based and offset-based pagination\n */\nexport const paginationSchema = z\n  .intersection(\n    z.object({\n      withCount: z.boolean().optional().describe('Include total count in response'),\n    }),\n    z.union([\n      z\n        .object({\n          page: z.number().int().positive().describe('Page number (1-based)'),\n          pageSize: z.number().int().positive().describe('Number of entries per page'),\n        })\n        .describe('Page-based pagination'),\n      z\n        .object({\n          start: z.number().int().min(0).describe('Number of entries to skip'),\n          limit: z.number().int().positive().describe('Maximum number of entries to return'),\n        })\n        .describe('Offset-based pagination'),\n    ])\n  )\n  .describe('Pagination parameters');\n\n/**\n * Filters parameter validation\n * Supports any object structure for filtering\n */\nexport const filtersSchema = z.record(z.string(), z.any()).describe('Apply filters to the query');\n\n/**\n * Locale parameter validation\n * Used for internationalization\n */\nexport const localeSchema = z.string().describe('Specify the locale for localized content');\n\n/**\n * Status parameter validation\n * Used for draft & publish functionality\n */\nexport const statusSchema = z.enum(['draft', 'published']).describe('Filter by publication status');\n\n/**\n * Search query parameter validation\n * Used for text search functionality\n */\nexport const searchQuerySchema = z.string().describe('Search query string');\n\n/**\n * Complete collection of all standard query parameter schemas\n * This object provides easy access to all available query parameter validators\n */\nexport const queryParameterSchemas = {\n  fields: queryFieldsSchema,\n  populate: queryPopulateSchema,\n  sort: querySortSchema,\n  pagination: paginationSchema,\n  filters: filtersSchema,\n  locale: localeSchema,\n  status: statusSchema,\n  _q: searchQuerySchema,\n} as const;\n\n/**\n * Query parameter names supported by Strapi's API\n */\nexport type QueryParam = keyof typeof queryParameterSchemas;\n"],"names":["queryFieldsSchema","z","union","string","array","describe","queryPopulateSchema","literal","record","any","querySortSchema","enum","paginationSchema","intersection","object","withCount","boolean","optional","page","number","int","positive","pageSize","start","min","limit","filtersSchema","localeSchema","statusSchema","searchQuerySchema","queryParameterSchemas","fields","populate","sort","pagination","filters","locale","status","_q"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAEA;;;;;;;;AAUC,IACM,MAAMA,iBAAoBC,GAAAA,YAAAA,CAC9BC,KAAK,CAAC;AAACD,IAAAA,YAAAA,CAAEE,MAAM,EAAA;IAAIF,YAAEG,CAAAA,KAAK,CAACH,YAAAA,CAAEE,MAAM,EAAA;CAAI,CACvCE,CAAAA,QAAQ,CAAC,kDAAoD;AAEhE;;;AAGC,IACM,MAAMC,mBAAsBL,GAAAA,YAAAA,CAChCC,KAAK,CAAC;AAACD,IAAAA,YAAAA,CAAEM,OAAO,CAAC,GAAA,CAAA;AAAMN,IAAAA,YAAAA,CAAEE,MAAM,EAAA;IAAIF,YAAEG,CAAAA,KAAK,CAACH,YAAAA,CAAEE,MAAM,EAAA,CAAA;AAAKF,IAAAA,YAAAA,CAAEO,MAAM,CAACP,YAAAA,CAAEE,MAAM,EAAA,EAAIF,aAAEQ,GAAG,EAAA;CAAI,CACtFJ,CAAAA,QAAQ,CAAC,qDAAuD;AAEnE;;;AAGC,IACM,MAAMK,eAAkBT,GAAAA,YAAAA,CAC5BC,KAAK,CAAC;AACLD,IAAAA,YAAAA,CAAEE,MAAM,EAAA;IACRF,YAAEG,CAAAA,KAAK,CAACH,YAAAA,CAAEE,MAAM,EAAA,CAAA;AAChBF,IAAAA,YAAAA,CAAEO,MAAM,CAACP,YAAAA,CAAEE,MAAM,EAAIF,EAAAA,YAAAA,CAAEU,IAAI,CAAC;AAAC,QAAA,KAAA;AAAO,QAAA;AAAO,KAAA,CAAA,CAAA;IAC3CV,YAAEG,CAAAA,KAAK,CAACH,YAAAA,CAAEO,MAAM,CAACP,aAAEE,MAAM,EAAA,EAAIF,YAAEU,CAAAA,IAAI,CAAC;AAAC,QAAA,KAAA;AAAO,QAAA;AAAO,KAAA,CAAA,CAAA;CACpD,CACAN,CAAAA,QAAQ,CAAC,sCAAwC;AAEpD;;;UAIaO,gBAAmBX,GAAAA,YAAAA,CAC7BY,YAAY,CACXZ,YAAAA,CAAEa,MAAM,CAAC;AACPC,IAAAA,SAAAA,EAAWd,aAAEe,OAAO,EAAA,CAAGC,QAAQ,EAAA,CAAGZ,QAAQ,CAAC,iCAAA;AAC7C,CACAJ,CAAAA,EAAAA,YAAAA,CAAEC,KAAK,CAAC;AACND,IAAAA,YAAAA,CACGa,MAAM,CAAC;QACNI,IAAMjB,EAAAA,YAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGC,QAAQ,EAAA,CAAGhB,QAAQ,CAAC,uBAAA,CAAA;QAC3CiB,QAAUrB,EAAAA,YAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGC,QAAQ,EAAA,CAAGhB,QAAQ,CAAC,4BAAA;AACjD,KAAA,CAAA,CACCA,QAAQ,CAAC,uBAAA,CAAA;AACZJ,IAAAA,YAAAA,CACGa,MAAM,CAAC;QACNS,KAAOtB,EAAAA,YAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGI,GAAG,CAAC,CAAGnB,CAAAA,CAAAA,QAAQ,CAAC,2BAAA,CAAA;QACxCoB,KAAOxB,EAAAA,YAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGC,QAAQ,EAAA,CAAGhB,QAAQ,CAAC,qCAAA;AAC9C,KAAA,CAAA,CACCA,QAAQ,CAAC,yBAAA;CACb,CAEFA,CAAAA,CAAAA,QAAQ,CAAC,uBAAyB;AAErC;;;AAGC,IACM,MAAMqB,aAAgBzB,GAAAA,YAAAA,CAAEO,MAAM,CAACP,YAAAA,CAAEE,MAAM,EAAA,EAAIF,YAAEQ,CAAAA,GAAG,EAAIJ,CAAAA,CAAAA,QAAQ,CAAC,4BAA8B;AAElG;;;UAIasB,YAAe1B,GAAAA,YAAAA,CAAEE,MAAM,EAAGE,CAAAA,QAAQ,CAAC,0CAA4C;AAE5F;;;AAGC,IACM,MAAMuB,YAAe3B,GAAAA,YAAAA,CAAEU,IAAI,CAAC;AAAC,IAAA,OAAA;AAAS,IAAA;CAAY,CAAEN,CAAAA,QAAQ,CAAC,8BAAgC;AAEpG;;;UAIawB,iBAAoB5B,GAAAA,YAAAA,CAAEE,MAAM,EAAGE,CAAAA,QAAQ,CAAC,qBAAuB;AAE5E;;;UAIayB,qBAAwB,GAAA;IACnCC,MAAQ/B,EAAAA,iBAAAA;IACRgC,QAAU1B,EAAAA,mBAAAA;IACV2B,IAAMvB,EAAAA,eAAAA;IACNwB,UAAYtB,EAAAA,gBAAAA;IACZuB,OAAST,EAAAA,aAAAA;IACTU,MAAQT,EAAAA,YAAAA;IACRU,MAAQT,EAAAA,YAAAA;IACRU,EAAIT,EAAAA;AACN;;;;;;;;;;;;"}

package/dist/validation/route-validators/query-params.mjs

@@ -0,0 +1,88 @@
+import * as z from 'zod/v4';
+
+/**
+ * Standard query parameter validators that can be reused across different route validators
+ *
+ * These schemas provide the basic structure validation for common Strapi API query parameters.
+ * They can be used as building blocks for both generic validation and schema-aware validation.
+ */ /**
+ * Fields parameter validation
+ * Supports: 'title', ['title', 'name'], or '*'
+ */ const queryFieldsSchema = z.union([
+    z.string(),
+    z.array(z.string())
+]).describe('Select specific fields to return in the response');
+/**
+ * Populate parameter validation
+ * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects
+ */ const queryPopulateSchema = z.union([
+    z.literal('*'),
+    z.string(),
+    z.array(z.string()),
+    z.record(z.string(), z.any())
+]).describe('Specify which relations to populate in the response');
+/**
+ * Sort parameter validation
+ * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]
+ */ const querySortSchema = z.union([
+    z.string(),
+    z.array(z.string()),
+    z.record(z.string(), z.enum([
+        'asc',
+        'desc'
+    ])),
+    z.array(z.record(z.string(), z.enum([
+        'asc',
+        'desc'
+    ])))
+]).describe('Sort the results by specified fields');
+/**
+ * Pagination parameter validation
+ * Supports both page-based and offset-based pagination
+ */ const paginationSchema = z.intersection(z.object({
+    withCount: z.boolean().optional().describe('Include total count in response')
+}), z.union([
+    z.object({
+        page: z.number().int().positive().describe('Page number (1-based)'),
+        pageSize: z.number().int().positive().describe('Number of entries per page')
+    }).describe('Page-based pagination'),
+    z.object({
+        start: z.number().int().min(0).describe('Number of entries to skip'),
+        limit: z.number().int().positive().describe('Maximum number of entries to return')
+    }).describe('Offset-based pagination')
+])).describe('Pagination parameters');
+/**
+ * Filters parameter validation
+ * Supports any object structure for filtering
+ */ const filtersSchema = z.record(z.string(), z.any()).describe('Apply filters to the query');
+/**
+ * Locale parameter validation
+ * Used for internationalization
+ */ const localeSchema = z.string().describe('Specify the locale for localized content');
+/**
+ * Status parameter validation
+ * Used for draft & publish functionality
+ */ const statusSchema = z.enum([
+    'draft',
+    'published'
+]).describe('Filter by publication status');
+/**
+ * Search query parameter validation
+ * Used for text search functionality
+ */ const searchQuerySchema = z.string().describe('Search query string');
+/**
+ * Complete collection of all standard query parameter schemas
+ * This object provides easy access to all available query parameter validators
+ */ const queryParameterSchemas = {
+    fields: queryFieldsSchema,
+    populate: queryPopulateSchema,
+    sort: querySortSchema,
+    pagination: paginationSchema,
+    filters: filtersSchema,
+    locale: localeSchema,
+    status: statusSchema,
+    _q: searchQuerySchema
+};
+
+export { filtersSchema, localeSchema, paginationSchema, queryFieldsSchema, queryParameterSchemas, queryPopulateSchema, querySortSchema, searchQuerySchema, statusSchema };
+//# sourceMappingURL=query-params.mjs.map

package/dist/validation/route-validators/query-params.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.mjs","sources":["../../../src/validation/route-validators/query-params.ts"],"sourcesContent":["import * as z from 'zod/v4';\n\n/**\n * Standard query parameter validators that can be reused across different route validators\n *\n * These schemas provide the basic structure validation for common Strapi API query parameters.\n * They can be used as building blocks for both generic validation and schema-aware validation.\n */\n\n/**\n * Fields parameter validation\n * Supports: 'title', ['title', 'name'], or '*'\n */\nexport const queryFieldsSchema = z\n  .union([z.string(), z.array(z.string())])\n  .describe('Select specific fields to return in the response');\n\n/**\n * Populate parameter validation\n * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects\n */\nexport const queryPopulateSchema = z\n  .union([z.literal('*'), z.string(), z.array(z.string()), z.record(z.string(), z.any())])\n  .describe('Specify which relations to populate in the response');\n\n/**\n * Sort parameter validation\n * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]\n */\nexport const querySortSchema = z\n  .union([\n    z.string(),\n    z.array(z.string()),\n    z.record(z.string(), z.enum(['asc', 'desc'])),\n    z.array(z.record(z.string(), z.enum(['asc', 'desc']))),\n  ])\n  .describe('Sort the results by specified fields');\n\n/**\n * Pagination parameter validation\n * Supports both page-based and offset-based pagination\n */\nexport const paginationSchema = z\n  .intersection(\n    z.object({\n      withCount: z.boolean().optional().describe('Include total count in response'),\n    }),\n    z.union([\n      z\n        .object({\n          page: z.number().int().positive().describe('Page number (1-based)'),\n          pageSize: z.number().int().positive().describe('Number of entries per page'),\n        })\n        .describe('Page-based pagination'),\n      z\n        .object({\n          start: z.number().int().min(0).describe('Number of entries to skip'),\n          limit: z.number().int().positive().describe('Maximum number of entries to return'),\n        })\n        .describe('Offset-based pagination'),\n    ])\n  )\n  .describe('Pagination parameters');\n\n/**\n * Filters parameter validation\n * Supports any object structure for filtering\n */\nexport const filtersSchema = z.record(z.string(), z.any()).describe('Apply filters to the query');\n\n/**\n * Locale parameter validation\n * Used for internationalization\n */\nexport const localeSchema = z.string().describe('Specify the locale for localized content');\n\n/**\n * Status parameter validation\n * Used for draft & publish functionality\n */\nexport const statusSchema = z.enum(['draft', 'published']).describe('Filter by publication status');\n\n/**\n * Search query parameter validation\n * Used for text search functionality\n */\nexport const searchQuerySchema = z.string().describe('Search query string');\n\n/**\n * Complete collection of all standard query parameter schemas\n * This object provides easy access to all available query parameter validators\n */\nexport const queryParameterSchemas = {\n  fields: queryFieldsSchema,\n  populate: queryPopulateSchema,\n  sort: querySortSchema,\n  pagination: paginationSchema,\n  filters: filtersSchema,\n  locale: localeSchema,\n  status: statusSchema,\n  _q: searchQuerySchema,\n} as const;\n\n/**\n * Query parameter names supported by Strapi's API\n */\nexport type QueryParam = keyof typeof queryParameterSchemas;\n"],"names":["queryFieldsSchema","z","union","string","array","describe","queryPopulateSchema","literal","record","any","querySortSchema","enum","paginationSchema","intersection","object","withCount","boolean","optional","page","number","int","positive","pageSize","start","min","limit","filtersSchema","localeSchema","statusSchema","searchQuerySchema","queryParameterSchemas","fields","populate","sort","pagination","filters","locale","status","_q"],"mappings":"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"}

package/dist/validation/utilities.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @file This file contains utility functions for working with Zod schemas.
+ * It provides functions to modify schemas (e.g., make them optional, readonly, or add default values),
+ * and to safely register and create schemas within Zod's global registry.
+ */
+import * as z from 'zod/v4';
+/**
+ * Transforms a Strapi UID into an OpenAPI-compliant component name.
+ *
+ * @param uid - The Strapi UID to transform (e.g., "basic.seo", "api::category.category", "plugin::upload.file")
+ * @returns The OpenAPI-compliant component name (e.g., "BasicSeoEntry", "ApiCategoryCategoryDocument", "PluginUploadFileDocument")
+ */
+export declare const transformUidToValidOpenApiName: (uid: string) => string;
+/**
+ * Conditionally makes a Zod schema optional based on the `required` parameter.
+ *
+ * @param required - If `false` or `undefined`, the schema will be made optional. If `true`, the schema becomes non-optional.
+ * @returns A function that takes a Zod schema and returns a modified schema (optional or required).
+ * @example
+ * ```typescript
+ * const optionalString = maybeRequired(false)(z.string()); // z.ZodOptional<z.ZodString>
+ *
+ * const requiredString = maybeRequired(true)(z.string());  // z.ZodString
+ * ```
+ */
+export declare const maybeRequired: (required?: boolean) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T) => z.ZodOptional<T> | z.ZodNonOptional<T>;
+/**
+ * Conditionally makes a Zod schema readonly based on the `writable` parameter.
+ *
+ * @param writable - If `false`, the schema will be made readonly. If `true` or `undefined`, the schema remains unchanged.
+ * @returns A function that takes a Zod schema and returns a modified schema (readonly or original).
+ * @example
+ * ```typescript
+ * const readonlyNumber = maybeReadonly(false)(z.number()); // z.ZodReadonly<z.ZodNumber>
+ * const writableNumber = maybeReadonly(true)(z.number());  // z.ZodNumber
+ * ```
+ */
+export declare const maybeReadonly: (writable?: boolean) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T) => T | z.ZodReadonly<T>;
+/**
+ * Conditionally adds a default value to a Zod schema based on the `defaultValue` parameter.
+ *
+ * @param defaultValue - The default value to apply to the schema. If `undefined`, no default value is added.
+ *                       If `defaultValue` is a function, its return value will be used as the default.
+ * @returns A function that takes a Zod schema and returns a modified schema (with default or original).
+ * @example
+ * ```typescript
+ * const stringWithDefault = maybeWithDefault("default")(z.string()); // z.ZodDefault<z.ZodString>
+ * const numberWithFunctionDefault = maybeWithDefault(() => Math.random())(z.number());
+ * ```
+ */
+export declare const maybeWithDefault: (defaultValue?: unknown) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T) => T | z.ZodDefault<T>;
+/**
+ * Conditionally applies `min` and `max` constraints to a Zod string, number, or array schema.
+ *
+ * @param min - The minimum value/length. If `undefined`, no minimum constraint is applied.
+ * @param max - The maximum value/length. If `undefined`, no maximum constraint is applied.
+ * @returns A function that takes a Zod string, number, or array schema and returns a modified schema (with min/max constraints or original).
+ * @example
+ * ```typescript
+ * const stringWithMinMax = maybeWithMinMax(5, 10)(z.string()); // z.ZodString with min(5) and max(10)
+ * const numberWithMinMax = maybeWithMinMax(0, 100)(z.number()); // z.ZodNumber with min(0) and max(100)
+ * ```
+ */
+export declare const maybeWithMinMax: (min?: number, max?: number) => <R extends z.ZodString | z.ZodNumber | z.ZodEmail | z.ZodArray<z.ZodAny>>(schema: R) => z.ZodString | z.ZodNumber | z.ZodEmail | z.ZodArray<z.ZodAny>;
+/**
+ * Applies a series of modifier functions to a Zod schema sequentially.
+ *
+ * @template T - The type of the Zod schema.
+ * @param schema - The initial Zod schema to which modifiers will be applied.
+ * @param modifiers - An array of functions, each taking a Zod schema and returning a modified schema.
+ * @returns The final Zod schema after all modifiers have been applied.
+ * @example
+ * ```typescript
+ * const modifiedSchema = augmentSchema(z.string(), [
+ *   maybeRequired(false),
+ *   maybeWithDefault("test")
+ * ]);
+ * ```
+ */
+export declare const augmentSchema: <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T, modifiers: ((schema: T) => z.Schema)[]) => T;
+//# sourceMappingURL=utilities.d.ts.map

package/dist/validation/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/validation/utilities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAS,MAAM,KAAG,MAyB5D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,cAAe,OAAO,iGACV,CAAC,2CAGtC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,cAAe,OAAO,iGACV,CAAC,yBACtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,kBAAmB,OAAO,iGACjB,CAAC,wBAQtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,SAAU,MAAM,QAAQ,MAAM,uFACiC,CAAC,kEAG3F,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,8FAChB,CAAC,aACE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,MAGvC,CAAC"}

package/dist/validation/utilities.js

@@ -0,0 +1,123 @@
+'use strict';
+
+/**
+ * @file This file contains utility functions for working with Zod schemas.
+ * It provides functions to modify schemas (e.g., make them optional, readonly, or add default values),
+ * and to safely register and create schemas within Zod's global registry.
+ */ /**
+ * Transforms a Strapi UID into an OpenAPI-compliant component name.
+ *
+ * @param uid - The Strapi UID to transform (e.g., "basic.seo", "api::category.category", "plugin::upload.file")
+ * @returns The OpenAPI-compliant component name (e.g., "BasicSeoEntry", "ApiCategoryCategoryDocument", "PluginUploadFileDocument")
+ */ const transformUidToValidOpenApiName = (uid)=>{
+    const capitalize = (str)=>{
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const toPascalCase = (str)=>{
+        return str.split(/[-_]/).map(capitalize).join('');
+    };
+    // Check if it contains double colons (other namespaced UIDs)
+    if (uid.includes('::')) {
+        const [namespace, ...rest] = uid.split('::');
+        const namespacePart = toPascalCase(namespace);
+        const restParts = rest.join('.').split('.').map(toPascalCase).map(capitalize);
+        return `${capitalize(namespacePart)}${restParts.join('')}Document`;
+    }
+    if (uid.includes('.')) {
+        // basic.seo -> BasicSeoEntry
+        const parts = uid.split('.');
+        const transformedParts = parts.map(toPascalCase).map(capitalize);
+        return `${transformedParts.join('')}Entry`;
+    }
+    return `${toPascalCase(capitalize(uid))}Schema`;
+};
+/**
+ * Conditionally makes a Zod schema optional based on the `required` parameter.
+ *
+ * @param required - If `false` or `undefined`, the schema will be made optional. If `true`, the schema becomes non-optional.
+ * @returns A function that takes a Zod schema and returns a modified schema (optional or required).
+ * @example
+ * ```typescript
+ * const optionalString = maybeRequired(false)(z.string()); // z.ZodOptional<z.ZodString>
+ *
+ * const requiredString = maybeRequired(true)(z.string());  // z.ZodString
+ * ```
+ */ const maybeRequired = (required)=>{
+    return (schema)=>{
+        return required !== true ? schema.optional() : schema.nonoptional();
+    };
+};
+/**
+ * Conditionally makes a Zod schema readonly based on the `writable` parameter.
+ *
+ * @param writable - If `false`, the schema will be made readonly. If `true` or `undefined`, the schema remains unchanged.
+ * @returns A function that takes a Zod schema and returns a modified schema (readonly or original).
+ * @example
+ * ```typescript
+ * const readonlyNumber = maybeReadonly(false)(z.number()); // z.ZodReadonly<z.ZodNumber>
+ * const writableNumber = maybeReadonly(true)(z.number());  // z.ZodNumber
+ * ```
+ */ const maybeReadonly = (writable)=>{
+    return (schema)=>writable !== false ? schema : schema.readonly();
+};
+/**
+ * Conditionally adds a default value to a Zod schema based on the `defaultValue` parameter.
+ *
+ * @param defaultValue - The default value to apply to the schema. If `undefined`, no default value is added.
+ *                       If `defaultValue` is a function, its return value will be used as the default.
+ * @returns A function that takes a Zod schema and returns a modified schema (with default or original).
+ * @example
+ * ```typescript
+ * const stringWithDefault = maybeWithDefault("default")(z.string()); // z.ZodDefault<z.ZodString>
+ * const numberWithFunctionDefault = maybeWithDefault(() => Math.random())(z.number());
+ * ```
+ */ const maybeWithDefault = (defaultValue)=>{
+    return (schema)=>{
+        if (defaultValue === undefined) {
+            return schema;
+        }
+        const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+        return schema.default(value);
+    };
+};
+/**
+ * Conditionally applies `min` and `max` constraints to a Zod string, number, or array schema.
+ *
+ * @param min - The minimum value/length. If `undefined`, no minimum constraint is applied.
+ * @param max - The maximum value/length. If `undefined`, no maximum constraint is applied.
+ * @returns A function that takes a Zod string, number, or array schema and returns a modified schema (with min/max constraints or original).
+ * @example
+ * ```typescript
+ * const stringWithMinMax = maybeWithMinMax(5, 10)(z.string()); // z.ZodString with min(5) and max(10)
+ * const numberWithMinMax = maybeWithMinMax(0, 100)(z.number()); // z.ZodNumber with min(0) and max(100)
+ * ```
+ */ const maybeWithMinMax = (min, max)=>{
+    return (schema)=>{
+        return min !== undefined && max !== undefined ? schema.min(min).max(max) : schema;
+    };
+};
+/**
+ * Applies a series of modifier functions to a Zod schema sequentially.
+ *
+ * @template T - The type of the Zod schema.
+ * @param schema - The initial Zod schema to which modifiers will be applied.
+ * @param modifiers - An array of functions, each taking a Zod schema and returning a modified schema.
+ * @returns The final Zod schema after all modifiers have been applied.
+ * @example
+ * ```typescript
+ * const modifiedSchema = augmentSchema(z.string(), [
+ *   maybeRequired(false),
+ *   maybeWithDefault("test")
+ * ]);
+ * ```
+ */ const augmentSchema = (schema, modifiers)=>{
+    return modifiers.reduce((acc, modifier)=>modifier(acc), schema);
+};
+
+exports.augmentSchema = augmentSchema;
+exports.maybeReadonly = maybeReadonly;
+exports.maybeRequired = maybeRequired;
+exports.maybeWithDefault = maybeWithDefault;
+exports.maybeWithMinMax = maybeWithMinMax;
+exports.transformUidToValidOpenApiName = transformUidToValidOpenApiName;
+//# sourceMappingURL=utilities.js.map

package/dist/validation/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sources":["../../src/validation/utilities.ts"],"sourcesContent":["/**\n * @file This file contains utility functions for working with Zod schemas.\n * It provides functions to modify schemas (e.g., make them optional, readonly, or add default values),\n * and to safely register and create schemas within Zod's global registry.\n */\n\nimport * as z from 'zod/v4';\n\n/**\n * Transforms a Strapi UID into an OpenAPI-compliant component name.\n *\n * @param uid - The Strapi UID to transform (e.g., \"basic.seo\", \"api::category.category\", \"plugin::upload.file\")\n * @returns The OpenAPI-compliant component name (e.g., \"BasicSeoEntry\", \"ApiCategoryCategoryDocument\", \"PluginUploadFileDocument\")\n */\nexport const transformUidToValidOpenApiName = (uid: string): string => {\n  const capitalize = (str: string): string => {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n  };\n\n  const toPascalCase = (str: string): string => {\n    return str.split(/[-_]/).map(capitalize).join('');\n  };\n\n  // Check if it contains double colons (other namespaced UIDs)\n  if (uid.includes('::')) {\n    const [namespace, ...rest] = uid.split('::');\n    const namespacePart = toPascalCase(namespace);\n    const restParts = rest.join('.').split('.').map(toPascalCase).map(capitalize);\n    return `${capitalize(namespacePart)}${restParts.join('')}Document`;\n  }\n\n  if (uid.includes('.')) {\n    // basic.seo -> BasicSeoEntry\n    const parts = uid.split('.');\n    const transformedParts = parts.map(toPascalCase).map(capitalize);\n    return `${transformedParts.join('')}Entry`;\n  }\n\n  return `${toPascalCase(capitalize(uid))}Schema`;\n};\n\n/**\n * Conditionally makes a Zod schema optional based on the `required` parameter.\n *\n * @param required - If `false` or `undefined`, the schema will be made optional. If `true`, the schema becomes non-optional.\n * @returns A function that takes a Zod schema and returns a modified schema (optional or required).\n * @example\n * ```typescript\n * const optionalString = maybeRequired(false)(z.string()); // z.ZodOptional<z.ZodString>\n *\n * const requiredString = maybeRequired(true)(z.string());  // z.ZodString\n * ```\n */\nexport const maybeRequired = (required?: boolean) => {\n  return <T extends z.Schema>(schema: T) => {\n    return required !== true ? schema.optional() : schema.nonoptional();\n  };\n};\n\n/**\n * Conditionally makes a Zod schema readonly based on the `writable` parameter.\n *\n * @param writable - If `false`, the schema will be made readonly. If `true` or `undefined`, the schema remains unchanged.\n * @returns A function that takes a Zod schema and returns a modified schema (readonly or original).\n * @example\n * ```typescript\n * const readonlyNumber = maybeReadonly(false)(z.number()); // z.ZodReadonly<z.ZodNumber>\n * const writableNumber = maybeReadonly(true)(z.number());  // z.ZodNumber\n * ```\n */\nexport const maybeReadonly = (writable?: boolean) => {\n  return <T extends z.Schema>(schema: T) => (writable !== false ? schema : schema.readonly());\n};\n\n/**\n * Conditionally adds a default value to a Zod schema based on the `defaultValue` parameter.\n *\n * @param defaultValue - The default value to apply to the schema. If `undefined`, no default value is added.\n *                       If `defaultValue` is a function, its return value will be used as the default.\n * @returns A function that takes a Zod schema and returns a modified schema (with default or original).\n * @example\n * ```typescript\n * const stringWithDefault = maybeWithDefault(\"default\")(z.string()); // z.ZodDefault<z.ZodString>\n * const numberWithFunctionDefault = maybeWithDefault(() => Math.random())(z.number());\n * ```\n */\nexport const maybeWithDefault = (defaultValue?: unknown) => {\n  return <T extends z.Schema>(schema: T) => {\n    if (defaultValue === undefined) {\n      return schema;\n    }\n\n    const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n    return schema.default(value);\n  };\n};\n\n/**\n * Conditionally applies `min` and `max` constraints to a Zod string, number, or array schema.\n *\n * @param min - The minimum value/length. If `undefined`, no minimum constraint is applied.\n * @param max - The maximum value/length. If `undefined`, no maximum constraint is applied.\n * @returns A function that takes a Zod string, number, or array schema and returns a modified schema (with min/max constraints or original).\n * @example\n * ```typescript\n * const stringWithMinMax = maybeWithMinMax(5, 10)(z.string()); // z.ZodString with min(5) and max(10)\n * const numberWithMinMax = maybeWithMinMax(0, 100)(z.number()); // z.ZodNumber with min(0) and max(100)\n * ```\n */\nexport const maybeWithMinMax = (min?: number, max?: number) => {\n  return <R extends z.ZodString | z.ZodEmail | z.ZodNumber | z.ZodArray<z.ZodAny>>(schema: R) => {\n    return min !== undefined && max !== undefined ? schema.min(min).max(max) : schema;\n  };\n};\n\n/**\n * Applies a series of modifier functions to a Zod schema sequentially.\n *\n * @template T - The type of the Zod schema.\n * @param schema - The initial Zod schema to which modifiers will be applied.\n * @param modifiers - An array of functions, each taking a Zod schema and returning a modified schema.\n * @returns The final Zod schema after all modifiers have been applied.\n * @example\n * ```typescript\n * const modifiedSchema = augmentSchema(z.string(), [\n *   maybeRequired(false),\n *   maybeWithDefault(\"test\")\n * ]);\n * ```\n */\nexport const augmentSchema = <T extends z.Schema>(\n  schema: T,\n  modifiers: ((schema: T) => z.Schema)[]\n) => {\n  return modifiers.reduce((acc, modifier) => modifier(acc) as T, schema);\n};\n"],"names":["transformUidToValidOpenApiName","uid","capitalize","str","charAt","toUpperCase","slice","toPascalCase","split","map","join","includes","namespace","rest","namespacePart","restParts","parts","transformedParts","maybeRequired","required","schema","optional","nonoptional","maybeReadonly","writable","readonly","maybeWithDefault","defaultValue","undefined","value","default","maybeWithMinMax","min","max","augmentSchema","modifiers","reduce","acc","modifier"],"mappings":"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"}

package/dist/validation/utilities.mjs

@@ -0,0 +1,116 @@
+/**
+ * @file This file contains utility functions for working with Zod schemas.
+ * It provides functions to modify schemas (e.g., make them optional, readonly, or add default values),
+ * and to safely register and create schemas within Zod's global registry.
+ */ /**
+ * Transforms a Strapi UID into an OpenAPI-compliant component name.
+ *
+ * @param uid - The Strapi UID to transform (e.g., "basic.seo", "api::category.category", "plugin::upload.file")
+ * @returns The OpenAPI-compliant component name (e.g., "BasicSeoEntry", "ApiCategoryCategoryDocument", "PluginUploadFileDocument")
+ */ const transformUidToValidOpenApiName = (uid)=>{
+    const capitalize = (str)=>{
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const toPascalCase = (str)=>{
+        return str.split(/[-_]/).map(capitalize).join('');
+    };
+    // Check if it contains double colons (other namespaced UIDs)
+    if (uid.includes('::')) {
+        const [namespace, ...rest] = uid.split('::');
+        const namespacePart = toPascalCase(namespace);
+        const restParts = rest.join('.').split('.').map(toPascalCase).map(capitalize);
+        return `${capitalize(namespacePart)}${restParts.join('')}Document`;
+    }
+    if (uid.includes('.')) {
+        // basic.seo -> BasicSeoEntry
+        const parts = uid.split('.');
+        const transformedParts = parts.map(toPascalCase).map(capitalize);
+        return `${transformedParts.join('')}Entry`;
+    }
+    return `${toPascalCase(capitalize(uid))}Schema`;
+};
+/**
+ * Conditionally makes a Zod schema optional based on the `required` parameter.
+ *
+ * @param required - If `false` or `undefined`, the schema will be made optional. If `true`, the schema becomes non-optional.
+ * @returns A function that takes a Zod schema and returns a modified schema (optional or required).
+ * @example
+ * ```typescript
+ * const optionalString = maybeRequired(false)(z.string()); // z.ZodOptional<z.ZodString>
+ *
+ * const requiredString = maybeRequired(true)(z.string());  // z.ZodString
+ * ```
+ */ const maybeRequired = (required)=>{
+    return (schema)=>{
+        return required !== true ? schema.optional() : schema.nonoptional();
+    };
+};
+/**
+ * Conditionally makes a Zod schema readonly based on the `writable` parameter.
+ *
+ * @param writable - If `false`, the schema will be made readonly. If `true` or `undefined`, the schema remains unchanged.
+ * @returns A function that takes a Zod schema and returns a modified schema (readonly or original).
+ * @example
+ * ```typescript
+ * const readonlyNumber = maybeReadonly(false)(z.number()); // z.ZodReadonly<z.ZodNumber>
+ * const writableNumber = maybeReadonly(true)(z.number());  // z.ZodNumber
+ * ```
+ */ const maybeReadonly = (writable)=>{
+    return (schema)=>writable !== false ? schema : schema.readonly();
+};
+/**
+ * Conditionally adds a default value to a Zod schema based on the `defaultValue` parameter.
+ *
+ * @param defaultValue - The default value to apply to the schema. If `undefined`, no default value is added.
+ *                       If `defaultValue` is a function, its return value will be used as the default.
+ * @returns A function that takes a Zod schema and returns a modified schema (with default or original).
+ * @example
+ * ```typescript
+ * const stringWithDefault = maybeWithDefault("default")(z.string()); // z.ZodDefault<z.ZodString>
+ * const numberWithFunctionDefault = maybeWithDefault(() => Math.random())(z.number());
+ * ```
+ */ const maybeWithDefault = (defaultValue)=>{
+    return (schema)=>{
+        if (defaultValue === undefined) {
+            return schema;
+        }
+        const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+        return schema.default(value);
+    };
+};
+/**
+ * Conditionally applies `min` and `max` constraints to a Zod string, number, or array schema.
+ *
+ * @param min - The minimum value/length. If `undefined`, no minimum constraint is applied.
+ * @param max - The maximum value/length. If `undefined`, no maximum constraint is applied.
+ * @returns A function that takes a Zod string, number, or array schema and returns a modified schema (with min/max constraints or original).
+ * @example
+ * ```typescript
+ * const stringWithMinMax = maybeWithMinMax(5, 10)(z.string()); // z.ZodString with min(5) and max(10)
+ * const numberWithMinMax = maybeWithMinMax(0, 100)(z.number()); // z.ZodNumber with min(0) and max(100)
+ * ```
+ */ const maybeWithMinMax = (min, max)=>{
+    return (schema)=>{
+        return min !== undefined && max !== undefined ? schema.min(min).max(max) : schema;
+    };
+};
+/**
+ * Applies a series of modifier functions to a Zod schema sequentially.
+ *
+ * @template T - The type of the Zod schema.
+ * @param schema - The initial Zod schema to which modifiers will be applied.
+ * @param modifiers - An array of functions, each taking a Zod schema and returning a modified schema.
+ * @returns The final Zod schema after all modifiers have been applied.
+ * @example
+ * ```typescript
+ * const modifiedSchema = augmentSchema(z.string(), [
+ *   maybeRequired(false),
+ *   maybeWithDefault("test")
+ * ]);
+ * ```
+ */ const augmentSchema = (schema, modifiers)=>{
+    return modifiers.reduce((acc, modifier)=>modifier(acc), schema);
+};
+
+export { augmentSchema, maybeReadonly, maybeRequired, maybeWithDefault, maybeWithMinMax, transformUidToValidOpenApiName };
+//# sourceMappingURL=utilities.mjs.map

package/dist/validation/utilities.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.mjs","sources":["../../src/validation/utilities.ts"],"sourcesContent":["/**\n * @file This file contains utility functions for working with Zod schemas.\n * It provides functions to modify schemas (e.g., make them optional, readonly, or add default values),\n * and to safely register and create schemas within Zod's global registry.\n */\n\nimport * as z from 'zod/v4';\n\n/**\n * Transforms a Strapi UID into an OpenAPI-compliant component name.\n *\n * @param uid - The Strapi UID to transform (e.g., \"basic.seo\", \"api::category.category\", \"plugin::upload.file\")\n * @returns The OpenAPI-compliant component name (e.g., \"BasicSeoEntry\", \"ApiCategoryCategoryDocument\", \"PluginUploadFileDocument\")\n */\nexport const transformUidToValidOpenApiName = (uid: string): string => {\n  const capitalize = (str: string): string => {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n  };\n\n  const toPascalCase = (str: string): string => {\n    return str.split(/[-_]/).map(capitalize).join('');\n  };\n\n  // Check if it contains double colons (other namespaced UIDs)\n  if (uid.includes('::')) {\n    const [namespace, ...rest] = uid.split('::');\n    const namespacePart = toPascalCase(namespace);\n    const restParts = rest.join('.').split('.').map(toPascalCase).map(capitalize);\n    return `${capitalize(namespacePart)}${restParts.join('')}Document`;\n  }\n\n  if (uid.includes('.')) {\n    // basic.seo -> BasicSeoEntry\n    const parts = uid.split('.');\n    const transformedParts = parts.map(toPascalCase).map(capitalize);\n    return `${transformedParts.join('')}Entry`;\n  }\n\n  return `${toPascalCase(capitalize(uid))}Schema`;\n};\n\n/**\n * Conditionally makes a Zod schema optional based on the `required` parameter.\n *\n * @param required - If `false` or `undefined`, the schema will be made optional. If `true`, the schema becomes non-optional.\n * @returns A function that takes a Zod schema and returns a modified schema (optional or required).\n * @example\n * ```typescript\n * const optionalString = maybeRequired(false)(z.string()); // z.ZodOptional<z.ZodString>\n *\n * const requiredString = maybeRequired(true)(z.string());  // z.ZodString\n * ```\n */\nexport const maybeRequired = (required?: boolean) => {\n  return <T extends z.Schema>(schema: T) => {\n    return required !== true ? schema.optional() : schema.nonoptional();\n  };\n};\n\n/**\n * Conditionally makes a Zod schema readonly based on the `writable` parameter.\n *\n * @param writable - If `false`, the schema will be made readonly. If `true` or `undefined`, the schema remains unchanged.\n * @returns A function that takes a Zod schema and returns a modified schema (readonly or original).\n * @example\n * ```typescript\n * const readonlyNumber = maybeReadonly(false)(z.number()); // z.ZodReadonly<z.ZodNumber>\n * const writableNumber = maybeReadonly(true)(z.number());  // z.ZodNumber\n * ```\n */\nexport const maybeReadonly = (writable?: boolean) => {\n  return <T extends z.Schema>(schema: T) => (writable !== false ? schema : schema.readonly());\n};\n\n/**\n * Conditionally adds a default value to a Zod schema based on the `defaultValue` parameter.\n *\n * @param defaultValue - The default value to apply to the schema. If `undefined`, no default value is added.\n *                       If `defaultValue` is a function, its return value will be used as the default.\n * @returns A function that takes a Zod schema and returns a modified schema (with default or original).\n * @example\n * ```typescript\n * const stringWithDefault = maybeWithDefault(\"default\")(z.string()); // z.ZodDefault<z.ZodString>\n * const numberWithFunctionDefault = maybeWithDefault(() => Math.random())(z.number());\n * ```\n */\nexport const maybeWithDefault = (defaultValue?: unknown) => {\n  return <T extends z.Schema>(schema: T) => {\n    if (defaultValue === undefined) {\n      return schema;\n    }\n\n    const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n    return schema.default(value);\n  };\n};\n\n/**\n * Conditionally applies `min` and `max` constraints to a Zod string, number, or array schema.\n *\n * @param min - The minimum value/length. If `undefined`, no minimum constraint is applied.\n * @param max - The maximum value/length. If `undefined`, no maximum constraint is applied.\n * @returns A function that takes a Zod string, number, or array schema and returns a modified schema (with min/max constraints or original).\n * @example\n * ```typescript\n * const stringWithMinMax = maybeWithMinMax(5, 10)(z.string()); // z.ZodString with min(5) and max(10)\n * const numberWithMinMax = maybeWithMinMax(0, 100)(z.number()); // z.ZodNumber with min(0) and max(100)\n * ```\n */\nexport const maybeWithMinMax = (min?: number, max?: number) => {\n  return <R extends z.ZodString | z.ZodEmail | z.ZodNumber | z.ZodArray<z.ZodAny>>(schema: R) => {\n    return min !== undefined && max !== undefined ? schema.min(min).max(max) : schema;\n  };\n};\n\n/**\n * Applies a series of modifier functions to a Zod schema sequentially.\n *\n * @template T - The type of the Zod schema.\n * @param schema - The initial Zod schema to which modifiers will be applied.\n * @param modifiers - An array of functions, each taking a Zod schema and returning a modified schema.\n * @returns The final Zod schema after all modifiers have been applied.\n * @example\n * ```typescript\n * const modifiedSchema = augmentSchema(z.string(), [\n *   maybeRequired(false),\n *   maybeWithDefault(\"test\")\n * ]);\n * ```\n */\nexport const augmentSchema = <T extends z.Schema>(\n  schema: T,\n  modifiers: ((schema: T) => z.Schema)[]\n) => {\n  return modifiers.reduce((acc, modifier) => modifier(acc) as T, schema);\n};\n"],"names":["transformUidToValidOpenApiName","uid","capitalize","str","charAt","toUpperCase","slice","toPascalCase","split","map","join","includes","namespace","rest","namespacePart","restParts","parts","transformedParts","maybeRequired","required","schema","optional","nonoptional","maybeReadonly","writable","readonly","maybeWithDefault","defaultValue","undefined","value","default","maybeWithMinMax","min","max","augmentSchema","modifiers","reduce","acc","modifier"],"mappings":"AAAA;;;;;;;;;IAcaA,MAAAA,8BAAAA,GAAiC,CAACC,GAAAA,GAAAA;AAC7C,IAAA,MAAMC,aAAa,CAACC,GAAAA,GAAAA;QAClB,OAAOA,GAAAA,CAAIC,MAAM,CAAC,CAAA,CAAA,CAAGC,WAAW,EAAKF,GAAAA,GAAAA,CAAIG,KAAK,CAAC,CAAA,CAAA;AACjD,KAAA;AAEA,IAAA,MAAMC,eAAe,CAACJ,GAAAA,GAAAA;QACpB,OAAOA,GAAAA,CAAIK,KAAK,CAAC,MAAA,CAAA,CAAQC,GAAG,CAACP,UAAAA,CAAAA,CAAYQ,IAAI,CAAC,EAAA,CAAA;AAChD,KAAA;;IAGA,IAAIT,GAAAA,CAAIU,QAAQ,CAAC,IAAO,CAAA,EAAA;AACtB,QAAA,MAAM,CAACC,SAAW,EAAA,GAAGC,KAAK,GAAGZ,GAAAA,CAAIO,KAAK,CAAC,IAAA,CAAA;AACvC,QAAA,MAAMM,gBAAgBP,YAAaK,CAAAA,SAAAA,CAAAA;AACnC,QAAA,MAAMG,SAAYF,GAAAA,IAAAA,CAAKH,IAAI,CAAC,GAAKF,CAAAA,CAAAA,KAAK,CAAC,GAAA,CAAA,CAAKC,GAAG,CAACF,YAAcE,CAAAA,CAAAA,GAAG,CAACP,UAAAA,CAAAA;QAClE,OAAO,CAAC,EAAEA,UAAAA,CAAWY,aAAe,CAAA,CAAA,EAAEC,UAAUL,IAAI,CAAC,EAAI,CAAA,CAAA,QAAQ,CAAC;AACpE;IAEA,IAAIT,GAAAA,CAAIU,QAAQ,CAAC,GAAM,CAAA,EAAA;;QAErB,MAAMK,KAAAA,GAAQf,GAAIO,CAAAA,KAAK,CAAC,GAAA,CAAA;AACxB,QAAA,MAAMS,mBAAmBD,KAAMP,CAAAA,GAAG,CAACF,YAAAA,CAAAA,CAAcE,GAAG,CAACP,UAAAA,CAAAA;AACrD,QAAA,OAAO,CAAC,EAAEe,gBAAAA,CAAiBP,IAAI,CAAC,EAAA,CAAA,CAAI,KAAK,CAAC;AAC5C;AAEA,IAAA,OAAO,CAAC,EAAEH,YAAAA,CAAaL,UAAWD,CAAAA,GAAAA,CAAAA,CAAAA,CAAM,MAAM,CAAC;AACjD;AAEA;;;;;;;;;;;IAYaiB,MAAAA,aAAAA,GAAgB,CAACC,QAAAA,GAAAA;AAC5B,IAAA,OAAO,CAAqBC,MAAAA,GAAAA;AAC1B,QAAA,OAAOD,aAAa,IAAOC,GAAAA,MAAAA,CAAOC,QAAQ,EAAA,GAAKD,OAAOE,WAAW,EAAA;AACnE,KAAA;AACF;AAEA;;;;;;;;;;IAWaC,MAAAA,aAAAA,GAAgB,CAACC,QAAAA,GAAAA;AAC5B,IAAA,OAAO,CAAqBJ,MAAeI,GAAAA,QAAAA,KAAa,KAAQJ,GAAAA,MAAAA,GAASA,OAAOK,QAAQ,EAAA;AAC1F;AAEA;;;;;;;;;;;IAYaC,MAAAA,gBAAAA,GAAmB,CAACC,YAAAA,GAAAA;AAC/B,IAAA,OAAO,CAAqBP,MAAAA,GAAAA;AAC1B,QAAA,IAAIO,iBAAiBC,SAAW,EAAA;YAC9B,OAAOR,MAAAA;AACT;AAEA,QAAA,MAAMS,KAAQ,GAAA,OAAOF,YAAiB,KAAA,UAAA,GAAaA,YAAiBA,EAAAA,GAAAA,YAAAA;QACpE,OAAOP,MAAAA,CAAOU,OAAO,CAACD,KAAAA,CAAAA;AACxB,KAAA;AACF;AAEA;;;;;;;;;;;AAWC,IACM,MAAME,eAAkB,GAAA,CAACC,GAAcC,EAAAA,GAAAA,GAAAA;AAC5C,IAAA,OAAO,CAA0Eb,MAAAA,GAAAA;QAC/E,OAAOY,GAAAA,KAAQJ,SAAaK,IAAAA,GAAAA,KAAQL,SAAYR,GAAAA,MAAAA,CAAOY,GAAG,CAACA,GAAAA,CAAAA,CAAKC,GAAG,CAACA,GAAOb,CAAAA,GAAAA,MAAAA;AAC7E,KAAA;AACF;AAEA;;;;;;;;;;;;;;AAcC,IACM,MAAMc,aAAgB,GAAA,CAC3Bd,MACAe,EAAAA,SAAAA,GAAAA;AAEA,IAAA,OAAOA,UAAUC,MAAM,CAAC,CAACC,GAAKC,EAAAA,QAAAA,GAAaA,SAASD,GAAWjB,CAAAA,EAAAA,MAAAA,CAAAA;AACjE;;;;"}

package/dist/zod.js

@@ -17,11 +17,11 @@ const validateZod = (schema)=>(data)=>{
         }
     };
 const formatZodErrors = (zodError)=>({
-        errors: zodError.format((issue)=>{
+        errors: zodError.issues.map((issue)=>{
             return {
                 path: issue.path,
                 message: issue.message,
-                name: issue.code
+                name: 'ValidationError'
             };
         }),
         message: 'Validation error'

package/dist/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.format((issue) => {\n    return {\n      path: issue.path,\n      message: issue.message,\n      name: issue.code,\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","format","issue","path","name","code"],"mappings":";;;;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,KAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,UAAEC,QAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,uBAAgBH,OAAS,EAAA;AAAEC,4BAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;QACjDH,MAAQG,EAAAA,QAAAA,CAASC,MAAM,CAAC,CAACC,KAAAA,GAAAA;YACvB,OAAO;AACLC,gBAAAA,IAAAA,EAAMD,MAAMC,IAAI;AAChBP,gBAAAA,OAAAA,EAASM,MAAMN,OAAO;AACtBQ,gBAAAA,IAAAA,EAAMF,MAAMG;AACd,aAAA;AACF,SAAA,CAAA;QACAT,OAAS,EAAA;KACX,CAAA;;;;"}
+{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.issues.map((issue) => {\n    return {\n      path: issue.path,\n      message: issue.message,\n      name: 'ValidationError',\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","issues","map","issue","path","name"],"mappings":";;;;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,KAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,UAAEC,QAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,uBAAgBH,OAAS,EAAA;AAAEC,4BAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;AACjDH,QAAAA,MAAAA,EAAQG,QAASC,CAAAA,MAAM,CAACC,GAAG,CAAC,CAACC,KAAAA,GAAAA;YAC3B,OAAO;AACLC,gBAAAA,IAAAA,EAAMD,MAAMC,IAAI;AAChBR,gBAAAA,OAAAA,EAASO,MAAMP,OAAO;gBACtBS,IAAM,EAAA;AACR,aAAA;AACF,SAAA,CAAA;QACAT,OAAS,EAAA;KACX,CAAA;;;;"}

package/dist/zod.mjs

@@ -15,11 +15,11 @@ const validateZod = (schema)=>(data)=>{
         }
     };
 const formatZodErrors = (zodError)=>({
-        errors: zodError.format((issue)=>{
+        errors: zodError.issues.map((issue)=>{
             return {
                 path: issue.path,
                 message: issue.message,
-                name: issue.code
+                name: 'ValidationError'
             };
         }),
         message: 'Validation error'

package/dist/zod.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"zod.mjs","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.format((issue) => {\n    return {\n      path: issue.path,\n      message: issue.message,\n      name: issue.code,\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","format","issue","path","name","code"],"mappings":";;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,CAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,gBAAgBH,OAAS,EAAA;AAAEC,oBAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;QACjDH,MAAQG,EAAAA,QAAAA,CAASC,MAAM,CAAC,CAACC,KAAAA,GAAAA;YACvB,OAAO;AACLC,gBAAAA,IAAAA,EAAMD,MAAMC,IAAI;AAChBP,gBAAAA,OAAAA,EAASM,MAAMN,OAAO;AACtBQ,gBAAAA,IAAAA,EAAMF,MAAMG;AACd,aAAA;AACF,SAAA,CAAA;QACAT,OAAS,EAAA;KACX,CAAA;;;;"}
+{"version":3,"file":"zod.mjs","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.issues.map((issue) => {\n    return {\n      path: issue.path,\n      message: issue.message,\n      name: 'ValidationError',\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","issues","map","issue","path","name"],"mappings":";;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,CAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,gBAAgBH,OAAS,EAAA;AAAEC,oBAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;AACjDH,QAAAA,MAAAA,EAAQG,QAASC,CAAAA,MAAM,CAACC,GAAG,CAAC,CAACC,KAAAA,GAAAA;YAC3B,OAAO;AACLC,gBAAAA,IAAAA,EAAMD,MAAMC,IAAI;AAChBR,gBAAAA,OAAAA,EAASO,MAAMP,OAAO;gBACtBS,IAAM,EAAA;AACR,aAAA;AACF,SAAA,CAAA;QACAT,OAAS,EAAA;KACX,CAAA;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/utils",
-  "version": "5.18.1",
+  "version": "5.20.0",
   "description": "Shared utilities for the Strapi packages",
   "keywords": [
     "strapi",
@@ -55,16 +55,16 @@
     "p-map": "4.0.0",
     "preferred-pm": "3.1.2",
     "yup": "0.32.9",
-    "zod": "3.24.2"
+    "zod": "3.25.67"
   },
   "devDependencies": {
     "@types/http-errors": "2.0.4",
     "@types/koa": "2.13.4",
     "@types/node": "18.19.24",
-    "eslint-config-custom": "5.18.1",
+    "eslint-config-custom": "5.20.0",
     "koa": "2.16.1",
     "koa-body": "6.0.1",
-    "tsconfig": "5.18.1"
+    "tsconfig": "5.20.0"
   },
   "engines": {
     "node": ">=18.0.0 <=22.x.x",