@strapi/content-type-builder 5.52.0 → 5.52.2

package/dist/server/controllers/validation/schema.js

@@ -1,17 +1,37 @@
 'use strict';
 
-var zod = require('zod');
+var z = require('zod/v4');
 var utils = require('@strapi/utils');
 var fp = require('lodash/fp');
 var builder = require('../../services/builder.js');
 var constants = require('../../services/constants.js');
 var common = require('./common.js');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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__*/_interopNamespace(z);
+
 const uniqueAttributeName = (attributes, ctx)=>{
     const names = new Set(attributes.map((attribute)=>fp.snakeCase(attribute.name)));
     if (names.size !== attributes.length) {
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'Attributes must have unique names'
         });
     }
@@ -28,13 +48,13 @@ const verifyUidTargetField = (attributes, ctx)=>{
                 // NOTE: on update we are setting it to undefined later in the process instead to handle renames
                 if (action === 'create') {
                     ctx.addIssue({
-                        code: zod.z.ZodIssueCode.custom,
+                        code: 'custom',
                         message: 'Target does not exist'
                     });
                 }
             } else if (!constants.VALID_UID_TARGETS.some((validUIdTarget)=>validUIdTarget === targetAttr.properties?.type)) {
                 ctx.addIssue({
-                    code: zod.z.ZodIssueCode.custom,
+                    code: 'custom',
                     message: 'Invalid target type'
                 });
             }
@@ -48,7 +68,7 @@ const verifySingularAndPluralNames = (obj, ctx)=>{
     }
     if (obj.singularName === obj.pluralName) {
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'Singular and plural names must be different',
             path: [
                 'singularName'
@@ -83,7 +103,7 @@ const verifyDraftAndPublishReservedAttributes = (contentType, ctx)=>{
     const reservedAttributeNames = utils.contentTypes.findDraftAndPublishReservedAttributeNames(getEffectiveAttributeNames(contentType));
     if (reservedAttributeNames.length > 0) {
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: utils.contentTypes.getDraftAndPublishEnableBlockedMessage(reservedAttributeNames),
             path: [
                 'draftAndPublish'
@@ -95,7 +115,7 @@ const maxLengthGreaterThanMinLength = (value, ctx)=>{
     if (!fp.isNil(value.maxLength) && !fp.isNil(value.minLength) && fp.isNumber(value.maxLength) && fp.isNumber(value.minLength)) {
         if (value.maxLength < value.minLength) {
             ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
+                code: 'custom',
                 message: 'maxLength must be greater or equal to minLength',
                 path: [
                     'maxLength'
@@ -108,7 +128,7 @@ const maxGreaterThanMin = (value, ctx)=>{
     if (!fp.isNil(value.max) && !fp.isNil(value.min) && fp.isNumber(value.max) && fp.isNumber(value.min)) {
         if (value.max < value.min) {
             ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
+                code: 'custom',
                 message: 'max must be greater or equal to min',
                 path: [
                     'max'
@@ -127,7 +147,7 @@ const checkUserTarget = (value, ctx)=>{
     const { target, relation, targetAttribute } = value;
     if (target === constants.coreUids.STRAPI_USER && (!STRAPI_USER_RELATIONS.includes(relation) || !fp.isUndefined(targetAttribute))) {
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             path: [
                 'relation'
             ],
@@ -138,7 +158,7 @@ const checkUserTarget = (value, ctx)=>{
 const uidRefinement = (value, ctx)=>{
     if (!fp.isNil(value.targetField) && !fp.isNil(value.default)) {
         ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'Cannot define a default UID if the targetField is set',
             path: [
                 'default'
@@ -150,7 +170,7 @@ const enumRefinement = (value, ctx)=>{
     if (value.type === 'enumeration' && !fp.isNil(value.default) && !fp.isNil(value.enum)) {
         if (value.default === '' || !value.enum.some((v)=>v === value.default)) {
             ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
+                code: 'custom',
                 message: 'Default value must be one of the enum values',
                 path: [
                     'default'
@@ -159,11 +179,11 @@ const enumRefinement = (value, ctx)=>{
         }
     }
 };
-const conditionSchema = zod.z.object({
-    visible: zod.z.record(zod.z.string(), zod.z.array(zod.z.any()))
+const conditionSchema = z__namespace.object({
+    visible: z__namespace.record(z__namespace.string(), z__namespace.array(z__namespace.any()))
 });
-const basePropertiesSchema = zod.z.object({
-    type: zod.z.enum([
+const basePropertiesSchema = z__namespace.object({
+    type: z__namespace.enum([
         'string',
         'text',
         'richtext',
@@ -188,24 +208,24 @@ const basePropertiesSchema = zod.z.object({
         'relation',
         'dynamiczone'
     ]),
-    configurable: zod.z.boolean().nullish(),
-    private: zod.z.boolean().nullish(),
-    pluginOptions: zod.z.record(zod.z.unknown()).optional(),
-    conditions: zod.z.preprocess((val)=>{
+    configurable: z__namespace.boolean().nullish(),
+    private: z__namespace.boolean().nullish(),
+    pluginOptions: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional(),
+    conditions: z__namespace.preprocess((val)=>{
         return val;
     }, conditionSchema.optional())
 });
-const maxLengthSchema = zod.z.number().int().positive().optional();
-const minLengthSchema = zod.z.number().int().positive().optional();
-const requiredSchema = zod.z.boolean().optional();
-const uniqueSchema = zod.z.boolean().optional();
+const maxLengthSchema = z__namespace.number().int().positive().optional();
+const minLengthSchema = z__namespace.number().int().positive().optional();
+const requiredSchema = z__namespace.boolean().optional();
+const uniqueSchema = z__namespace.boolean().optional();
 const STRAPI_USER_RELATIONS = [
     'oneToOne',
     'oneToMany'
 ];
-const baseRelationSchema = zod.z.object({
-    type: zod.z.literal('relation'),
-    relation: zod.z.enum([
+const baseRelationSchema = z__namespace.object({
+    type: z__namespace.literal('relation'),
+    relation: z__namespace.enum([
         'oneToOne',
         'oneToMany',
         'manyToOne',
@@ -215,57 +235,57 @@ const baseRelationSchema = zod.z.object({
         'morphToOne',
         'morphToMany'
     ]),
-    configurable: zod.z.boolean().nullish(),
+    configurable: z__namespace.boolean().nullish(),
     required: requiredSchema,
-    private: zod.z.boolean().nullish(),
-    pluginOptions: zod.z.record(zod.z.unknown()).optional(),
-    conditions: zod.z.preprocess((val)=>{
+    private: z__namespace.boolean().nullish(),
+    pluginOptions: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional(),
+    conditions: z__namespace.preprocess((val)=>{
         return val;
     }, conditionSchema.optional())
 });
 const oneToOneSchema = baseRelationSchema.extend({
-    relation: zod.z.literal('oneToOne'),
-    target: zod.z.string(),
-    targetAttribute: zod.z.string().nullish()
+    relation: z__namespace.literal('oneToOne'),
+    target: z__namespace.string(),
+    targetAttribute: z__namespace.string().nullish()
 });
 const oneWaySchema = baseRelationSchema.extend({
-    relation: zod.z.literal('oneToOne'),
-    target: zod.z.string()
+    relation: z__namespace.literal('oneToOne'),
+    target: z__namespace.string()
 });
 const oneToManySchema = baseRelationSchema.extend({
-    relation: zod.z.literal('oneToMany'),
-    target: zod.z.string(),
-    targetAttribute: zod.z.string().nullish()
+    relation: z__namespace.literal('oneToMany'),
+    target: z__namespace.string(),
+    targetAttribute: z__namespace.string().nullish()
 });
 const manyWaySchema = baseRelationSchema.extend({
-    relation: zod.z.literal('oneToMany'),
-    target: zod.z.string()
+    relation: z__namespace.literal('oneToMany'),
+    target: z__namespace.string()
 });
 const manyToOneSchema = baseRelationSchema.extend({
-    relation: zod.z.literal('manyToOne'),
-    target: zod.z.string(),
-    targetAttribute: zod.z.string().nullish()
+    relation: z__namespace.literal('manyToOne'),
+    target: z__namespace.string(),
+    targetAttribute: z__namespace.string().nullish()
 });
 const manyToManySchema = baseRelationSchema.extend({
-    relation: zod.z.literal('manyToMany'),
-    target: zod.z.string(),
-    targetAttribute: zod.z.string().nullish()
+    relation: z__namespace.literal('manyToMany'),
+    target: z__namespace.string(),
+    targetAttribute: z__namespace.string().nullish()
 });
 const morphOneSchema = baseRelationSchema.extend({
-    relation: zod.z.literal('morphOne'),
-    target: zod.z.string(),
-    targetAttribute: zod.z.string().nullish()
+    relation: z__namespace.literal('morphOne'),
+    target: z__namespace.string(),
+    targetAttribute: z__namespace.string().nullish()
 });
 const morphManySchema = baseRelationSchema.extend({
-    relation: zod.z.literal('morphMany'),
-    target: zod.z.string(),
-    targetAttribute: zod.z.string().nullish()
+    relation: z__namespace.literal('morphMany'),
+    target: z__namespace.string(),
+    targetAttribute: z__namespace.string().nullish()
 });
 const morphToOneSchema = baseRelationSchema.extend({
-    relation: zod.z.literal('morphToOne')
+    relation: z__namespace.literal('morphToOne')
 });
 const morphToManySchema = baseRelationSchema.extend({
-    relation: zod.z.literal('morphToMany')
+    relation: z__namespace.literal('morphToMany')
 });
 const createRelationSchema = (meta)=>{
     switch(meta.modelType){
@@ -273,7 +293,7 @@ const createRelationSchema = (meta)=>{
             {
                 switch(meta.kind){
                     case 'singleType':
-                        return zod.z.discriminatedUnion('relation', [
+                        return z__namespace.discriminatedUnion('relation', [
                             oneToOneSchema,
                             oneToManySchema,
                             morphOneSchema,
@@ -282,7 +302,7 @@ const createRelationSchema = (meta)=>{
                             morphToManySchema
                         ]);
                     case 'collectionType':
-                        return zod.z.discriminatedUnion('relation', [
+                        return z__namespace.discriminatedUnion('relation', [
                             oneToOneSchema,
                             oneToManySchema,
                             manyToOneSchema,
@@ -298,7 +318,7 @@ const createRelationSchema = (meta)=>{
             }
         case 'component':
             {
-                return zod.z.discriminatedUnion('relation', [
+                return z__namespace.discriminatedUnion('relation', [
                     oneWaySchema,
                     manyWaySchema
                 ]);
@@ -308,20 +328,20 @@ const createRelationSchema = (meta)=>{
     }
 };
 const richTextSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('richtext'),
+    type: z__namespace.literal('richtext'),
     required: requiredSchema,
     minLength: minLengthSchema,
     maxLength: maxLengthSchema,
-    default: zod.z.string().optional()
+    default: z__namespace.string().optional()
 });
 const blocksSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('blocks'),
+    type: z__namespace.literal('blocks'),
     required: requiredSchema
 });
 const jsonSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('json'),
+    type: z__namespace.literal('json'),
     required: requiredSchema,
-    default: zod.z.unknown().optional().refine((value)=>{
+    default: z__namespace.unknown().optional().refine((value)=>{
         if (value === undefined) {
             return true;
         }
@@ -337,13 +357,13 @@ const jsonSchema = basePropertiesSchema.extend({
     })
 });
 const enumerationSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('enumeration'),
+    type: z__namespace.literal('enumeration'),
     required: requiredSchema,
-    default: zod.z.string().optional(),
-    enumName: zod.z.string().optional().refine((value)=>{
+    default: z__namespace.string().optional(),
+    enumName: z__namespace.string().optional().refine((value)=>{
         return value === '' || common.NAME_REGEX.test(value);
     }, 'Invalid enum name'),
-    enum: zod.z.array(zod.z.string().refine((value)=>{
+    enum: z__namespace.array(z__namespace.string().refine((value)=>{
         return value === '' || !utils.strings.startsWithANumber(value);
     })).min(1).refine((values)=>{
         const filtered = [
@@ -353,105 +373,105 @@ const enumerationSchema = basePropertiesSchema.extend({
     })
 });
 const textSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('text'),
-    default: zod.z.string().nullish(),
+    type: z__namespace.literal('text'),
+    default: z__namespace.string().nullish(),
     minLength: minLengthSchema,
     maxLength: maxLengthSchema,
     required: requiredSchema,
     unique: uniqueSchema,
-    regex: zod.z.string().optional().refine((value)=>{
+    regex: z__namespace.string().optional().refine((value)=>{
         return value === '' || !!new RegExp(value);
     }, 'Invalid regular expression pattern')
 });
 const stringSchema = textSchema.extend({
-    type: zod.z.literal('string')
+    type: z__namespace.literal('string')
 });
 const passwordSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('password'),
+    type: z__namespace.literal('password'),
     required: requiredSchema,
     minLength: minLengthSchema,
     maxLength: maxLengthSchema
 });
 const emailSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('email'),
+    type: z__namespace.literal('email'),
     required: requiredSchema,
     minLength: minLengthSchema,
     maxLength: maxLengthSchema,
-    default: zod.z.string().email().optional(),
+    default: z__namespace.string().email().optional(),
     unique: uniqueSchema
 });
 const integerSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('integer'),
+    type: z__namespace.literal('integer'),
     required: requiredSchema,
-    default: zod.z.number().int().optional(),
+    default: z__namespace.number().int().optional(),
     unique: uniqueSchema,
-    min: zod.z.number().int().optional(),
-    max: zod.z.number().int().optional()
+    min: z__namespace.number().int().optional(),
+    max: z__namespace.number().int().optional()
 });
 const bigIntegerSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('biginteger'),
+    type: z__namespace.literal('biginteger'),
     required: requiredSchema,
     unique: uniqueSchema,
-    default: zod.z.string().regex(/^\d*$/).nullish(),
-    min: zod.z.string().regex(/^\d*$/).nullish(),
-    max: zod.z.string().regex(/^\d*$/).nullish()
+    default: z__namespace.string().regex(/^\d*$/).nullish(),
+    min: z__namespace.string().regex(/^\d*$/).nullish(),
+    max: z__namespace.string().regex(/^\d*$/).nullish()
 });
 const floatSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('float'),
+    type: z__namespace.literal('float'),
     required: requiredSchema,
     unique: uniqueSchema,
-    default: zod.z.number().optional(),
-    min: zod.z.number().optional(),
-    max: zod.z.number().optional()
+    default: z__namespace.number().optional(),
+    min: z__namespace.number().optional(),
+    max: z__namespace.number().optional()
 });
 const decimalSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('decimal'),
+    type: z__namespace.literal('decimal'),
     required: requiredSchema,
     unique: uniqueSchema,
-    default: zod.z.number().optional(),
-    min: zod.z.number().optional(),
-    max: zod.z.number().optional()
+    default: z__namespace.number().optional(),
+    min: z__namespace.number().optional(),
+    max: z__namespace.number().optional()
 });
 const timeSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('time'),
+    type: z__namespace.literal('time'),
     required: requiredSchema,
     unique: uniqueSchema,
-    default: zod.z.string().optional()
+    default: z__namespace.string().optional()
 });
 const dateSchema = timeSchema.extend({
-    type: zod.z.literal('date')
+    type: z__namespace.literal('date')
 });
 const dateTimeSchema = timeSchema.extend({
-    type: zod.z.literal('datetime')
+    type: z__namespace.literal('datetime')
 });
 const timeStampSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('timestamp')
+    type: z__namespace.literal('timestamp')
 });
 const booleanSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('boolean'),
+    type: z__namespace.literal('boolean'),
     required: requiredSchema,
-    default: zod.z.boolean().optional()
+    default: z__namespace.boolean().optional()
 });
 const componentSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('component'),
-    component: zod.z.string(),
-    repeatable: zod.z.boolean().optional(),
+    type: z__namespace.literal('component'),
+    component: z__namespace.string(),
+    repeatable: z__namespace.boolean().optional(),
     required: requiredSchema,
-    min: zod.z.number().optional(),
-    max: zod.z.number().optional()
+    min: z__namespace.number().optional(),
+    max: z__namespace.number().optional()
 });
 const dynamicZoneSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('dynamiczone'),
-    components: zod.z.array(zod.z.string()).nonempty(),
+    type: z__namespace.literal('dynamiczone'),
+    components: z__namespace.array(z__namespace.string()).nonempty(),
     required: requiredSchema,
-    min: zod.z.number().optional(),
-    max: zod.z.number().optional()
+    min: z__namespace.number().optional(),
+    max: z__namespace.number().optional()
 });
 const mediaSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('media'),
-    multiple: zod.z.boolean().optional(),
+    type: z__namespace.literal('media'),
+    multiple: z__namespace.boolean().optional(),
     required: requiredSchema,
-    allowedTypes: zod.z.array(zod.z.enum([
+    allowedTypes: z__namespace.array(z__namespace.enum([
         'images',
         'videos',
         'files',
@@ -459,30 +479,30 @@ const mediaSchema = basePropertiesSchema.extend({
     ])).nonempty().optional()
 });
 const uidSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('uid'),
-    targetField: zod.z.string().nullish(),
+    type: z__namespace.literal('uid'),
+    targetField: z__namespace.string().nullish(),
     required: requiredSchema,
-    default: zod.z.string().nullish(),
+    default: z__namespace.string().nullish(),
     minLength: minLengthSchema,
     maxLength: maxLengthSchema,
-    options: zod.z.object({
-        separator: zod.z.string().optional(),
-        lowercase: zod.z.boolean().optional(),
-        decamelize: zod.z.boolean().optional(),
-        customReplacements: zod.z.array(zod.z.array(zod.z.string()).length(2)).optional(),
-        preserveLeadingUnderscore: zod.z.boolean().optional()
+    options: z__namespace.object({
+        separator: z__namespace.string().optional(),
+        lowercase: z__namespace.boolean().optional(),
+        decamelize: z__namespace.boolean().optional(),
+        customReplacements: z__namespace.array(z__namespace.array(z__namespace.string()).length(2)).optional(),
+        preserveLeadingUnderscore: z__namespace.boolean().optional()
     }).optional(),
-    regex: zod.z.string().optional().refine((value)=>{
+    regex: z__namespace.string().optional().refine((value)=>{
         return value === '' || !!new RegExp(value);
     }, 'Invalid regular expression pattern')
 });
 const customFieldSchema = basePropertiesSchema.extend({
-    type: zod.z.literal('customField'),
-    customField: zod.z.string()
+    type: z__namespace.literal('customField'),
+    customField: z__namespace.string()
 });
 const attributePropertiesSchema = (meta)=>{
     const relationSchema = createRelationSchema(meta);
-    const base = zod.z.union([
+    const base = z__namespace.union([
         mediaSchema,
         textSchema,
         stringSchema,
@@ -508,52 +528,52 @@ const attributePropertiesSchema = (meta)=>{
     if (meta.modelType === 'component') {
         return base.superRefine(enumRefinement).superRefine(checkUserTarget).superRefine(maxGreaterThanMin).superRefine(maxLengthGreaterThanMinLength);
     }
-    return zod.z.union([
+    return z__namespace.union([
         ...base.options,
         uidSchema,
         dynamicZoneSchema
     ]).superRefine(enumRefinement).superRefine(checkUserTarget).superRefine(uidRefinement).superRefine(maxGreaterThanMin).superRefine(maxLengthGreaterThanMinLength);
 };
-const createAttributeSchema = (meta)=>zod.z.object({
-        action: zod.z.literal('create'),
-        name: zod.z.string().regex(common.NAME_REGEX).refine((value)=>!builder.isReservedAttributeName(value), 'Attribute name is reserved'),
+const createAttributeSchema = (meta)=>z__namespace.object({
+        action: z__namespace.literal('create'),
+        name: z__namespace.string().regex(common.NAME_REGEX).refine((value)=>!builder.isReservedAttributeName(value), 'Attribute name is reserved'),
         properties: attributePropertiesSchema(meta)
     });
-const updateAttributeSchema = (meta)=>zod.z.object({
-        action: zod.z.literal('update'),
-        name: zod.z.string(),
+const updateAttributeSchema = (meta)=>z__namespace.object({
+        action: z__namespace.literal('update'),
+        name: z__namespace.string(),
         properties: attributePropertiesSchema(meta)
     });
-const deleteAttributeSchema = zod.z.object({
-    action: zod.z.literal('delete'),
-    name: zod.z.string()
+const deleteAttributeSchema = z__namespace.object({
+    action: z__namespace.literal('delete'),
+    name: z__namespace.string()
 });
-const contentTypeUIDSchema = zod.z.custom((value)=>{
+const contentTypeUIDSchema = z__namespace.custom((value)=>{
     return typeof value === 'string' && value.length > 0;
 });
-const componentUIDSchema = zod.z.custom((value)=>{
+const componentUIDSchema = z__namespace.custom((value)=>{
     return typeof value === 'string' && value.length > 0;
 });
-const categorySchema = zod.z.string().min(1).regex(common.CATEGORY_NAME_REGEX);
-const baseComponentSchema = zod.z.object({
+const categorySchema = z__namespace.string().min(1).regex(common.CATEGORY_NAME_REGEX);
+const baseComponentSchema = z__namespace.object({
     uid: componentUIDSchema,
-    displayName: zod.z.string().min(1),
-    icon: zod.z.string().regex(common.ICON_REGEX).optional(),
-    description: zod.z.string().optional(),
+    displayName: z__namespace.string().min(1),
+    icon: z__namespace.string().regex(common.ICON_REGEX).optional(),
+    description: z__namespace.string().optional(),
     category: categorySchema,
-    pluginOptions: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    pluginOptions: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional()
 });
 const createComponentSchema = baseComponentSchema.extend({
-    action: zod.z.literal('create'),
-    config: zod.z.record(zod.z.string(), zod.z.unknown()).optional().default({}),
-    attributes: zod.z.array(createAttributeSchema({
+    action: z__namespace.literal('create'),
+    config: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional().default({}),
+    attributes: z__namespace.array(createAttributeSchema({
         modelType: 'component'
     })).superRefine(uniqueAttributeName)
 });
 const updateComponentSchema = baseComponentSchema.extend({
-    action: zod.z.literal('update'),
+    action: z__namespace.literal('update'),
     category: categorySchema.optional(),
-    attributes: zod.z.array(zod.z.discriminatedUnion('action', [
+    attributes: z__namespace.array(z__namespace.discriminatedUnion('action', [
         createAttributeSchema({
             modelType: 'component'
         }),
@@ -563,50 +583,50 @@ const updateComponentSchema = baseComponentSchema.extend({
         deleteAttributeSchema
     ])).superRefine(uniqueAttributeName)
 });
-const deleteComponentSchema = zod.z.object({
-    action: zod.z.literal('delete'),
+const deleteComponentSchema = z__namespace.object({
+    action: z__namespace.literal('delete'),
     uid: componentUIDSchema
 });
-const baseContentTypeSchema = zod.z.object({
+const baseContentTypeSchema = z__namespace.object({
     uid: contentTypeUIDSchema,
-    displayName: zod.z.string().min(1),
-    description: zod.z.string().optional(),
-    draftAndPublish: zod.z.boolean(),
-    options: zod.z.record(zod.z.unknown()).optional().default({}),
-    pluginOptions: zod.z.record(zod.z.unknown()).optional().default({}),
-    kind: zod.z.enum([
+    displayName: z__namespace.string().min(1),
+    description: z__namespace.string().optional(),
+    draftAndPublish: z__namespace.boolean(),
+    options: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional().default({}),
+    pluginOptions: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional().default({}),
+    kind: z__namespace.enum([
         constants.typeKinds.SINGLE_TYPE,
         constants.typeKinds.COLLECTION_TYPE
     ]).optional()
 });
 const baseCreateContentTypeSchema = baseContentTypeSchema.extend({
-    action: zod.z.literal('create'),
-    plugin: zod.z.string().min(1).optional(),
-    collectionName: zod.z.string().regex(common.COLLECTION_NAME_REGEX).optional(),
-    singularName: zod.z.string().min(1).regex(common.KEBAB_BASE_REGEX, 'Must be kebab case').refine((value)=>!builder.isReservedModelName(value), 'Model name is reserved'),
-    pluralName: zod.z.string().min(1).regex(common.KEBAB_BASE_REGEX, 'Must be kebab case').refine((value)=>!builder.isReservedModelName(value), 'Model name is reserved'),
-    config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    action: z__namespace.literal('create'),
+    plugin: z__namespace.string().min(1).optional(),
+    collectionName: z__namespace.string().regex(common.COLLECTION_NAME_REGEX).optional(),
+    singularName: z__namespace.string().min(1).regex(common.KEBAB_BASE_REGEX, 'Must be kebab case').refine((value)=>!builder.isReservedModelName(value), 'Model name is reserved'),
+    pluralName: z__namespace.string().min(1).regex(common.KEBAB_BASE_REGEX, 'Must be kebab case').refine((value)=>!builder.isReservedModelName(value), 'Model name is reserved'),
+    config: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional()
 });
 const createSingleTypeSchema = baseCreateContentTypeSchema.extend({
-    kind: zod.z.literal(constants.typeKinds.SINGLE_TYPE),
-    attributes: zod.z.array(createAttributeSchema({
+    kind: z__namespace.literal(constants.typeKinds.SINGLE_TYPE),
+    attributes: z__namespace.array(createAttributeSchema({
         modelType: 'contentType',
         kind: 'singleType'
     })).superRefine(uniqueAttributeName).superRefine(verifyUidTargetField)
 });
 const createCollectionTypeSchema = baseCreateContentTypeSchema.extend({
-    kind: zod.z.literal(constants.typeKinds.COLLECTION_TYPE),
-    attributes: zod.z.array(createAttributeSchema({
+    kind: z__namespace.literal(constants.typeKinds.COLLECTION_TYPE),
+    attributes: z__namespace.array(createAttributeSchema({
         modelType: 'contentType',
         kind: 'collectionType'
     })).superRefine(uniqueAttributeName).superRefine(verifyUidTargetField)
 });
 const baseUpdateContentTypeSchema = baseContentTypeSchema.extend({
-    action: zod.z.literal('update')
+    action: z__namespace.literal('update')
 });
 const updateSingleTypeSchema = baseUpdateContentTypeSchema.extend({
-    kind: zod.z.literal(constants.typeKinds.SINGLE_TYPE).optional(),
-    attributes: zod.z.array(zod.z.discriminatedUnion('action', [
+    kind: z__namespace.literal(constants.typeKinds.SINGLE_TYPE).optional(),
+    attributes: z__namespace.array(z__namespace.discriminatedUnion('action', [
         createAttributeSchema({
             modelType: 'contentType',
             kind: 'singleType'
@@ -619,8 +639,8 @@ const updateSingleTypeSchema = baseUpdateContentTypeSchema.extend({
     ])).superRefine(uniqueAttributeName).superRefine(verifyUidTargetField)
 });
 const updateCollectionTypeSchema = baseUpdateContentTypeSchema.extend({
-    kind: zod.z.literal(constants.typeKinds.COLLECTION_TYPE).optional(),
-    attributes: zod.z.array(zod.z.union([
+    kind: z__namespace.literal(constants.typeKinds.COLLECTION_TYPE).optional(),
+    attributes: z__namespace.array(z__namespace.union([
         createAttributeSchema({
             modelType: 'contentType',
             kind: 'collectionType'
@@ -632,17 +652,17 @@ const updateCollectionTypeSchema = baseUpdateContentTypeSchema.extend({
         deleteAttributeSchema
     ])).superRefine(uniqueAttributeName).superRefine(verifyUidTargetField)
 });
-const deleteContentTypeSchema = zod.z.object({
-    action: zod.z.literal('delete'),
+const deleteContentTypeSchema = z__namespace.object({
+    action: z__namespace.literal('delete'),
     uid: contentTypeUIDSchema
 });
-const schemaSchema = zod.z.object({
-    components: zod.z.array(zod.z.union([
+const schemaSchema = z__namespace.object({
+    components: z__namespace.array(z__namespace.union([
         createComponentSchema,
         updateComponentSchema,
         deleteComponentSchema
     ])).optional().default([]),
-    contentTypes: zod.z.array(zod.z.union([
+    contentTypes: z__namespace.array(z__namespace.union([
         createSingleTypeSchema,
         createCollectionTypeSchema,
         updateSingleTypeSchema,
@@ -650,13 +670,11 @@ const schemaSchema = zod.z.object({
         deleteContentTypeSchema
     ]).superRefine(verifySingularAndPluralNames).superRefine(verifyDraftAndPublishReservedAttributes)).optional().default([])
 });
-const updateSchemaInput = zod.z.object({
+const updateSchemaInput = z__namespace.object({
     data: schemaSchema
 }, {
-    invalid_type_error: 'Invalid schema, expected an object with a data property',
-    required_error: 'Schema is required'
+    error: (issue)=>issue.input === undefined ? 'Schema is required' : 'Invalid schema, expected an object with a data property'
 });
-// TODO: Remove cast when content-type-builder migrates to Zod 4
 const validateUpdateSchema = utils.validateZodSchema(updateSchemaInput);
 
 exports.maxGreaterThanMin = maxGreaterThanMin;