@strapi2front/generators 0.4.0 → 0.5.0

package/dist/index.js

@@ -1476,6 +1476,303 @@ ${findParams.join("\n")}
 };
 `;
 }
+
+// src/shared/blocks-schema.ts
+function getCompactBlocksSchema() {
+  return `z.array(
+  z.discriminatedUnion('type', [
+    z.object({ type: z.literal('paragraph'), children: z.array(z.object({ type: z.literal('text'), text: z.string() }).passthrough()) }),
+    z.object({ type: z.literal('heading'), level: z.number().int().min(1).max(6), children: z.array(z.object({ type: z.literal('text'), text: z.string() }).passthrough()) }),
+    z.object({ type: z.literal('list'), format: z.enum(['ordered', 'unordered']), children: z.array(z.object({ type: z.literal('list-item'), children: z.array(z.unknown()) })) }),
+    z.object({ type: z.literal('quote'), children: z.array(z.object({ type: z.literal('text'), text: z.string() }).passthrough()) }),
+    z.object({ type: z.literal('code'), children: z.array(z.object({ type: z.literal('text'), text: z.string() })) }),
+    z.object({ type: z.literal('image'), image: z.object({ url: z.string(), width: z.number(), height: z.number() }).passthrough(), children: z.array(z.unknown()) }),
+  ])
+)`;
+}
+
+// src/shared/zod-mapper.ts
+var SYSTEM_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "documentId",
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "localizations",
+  "locale"
+]);
+function isSystemField(fieldName) {
+  return SYSTEM_FIELDS.has(fieldName);
+}
+function mapAttributeToZodSchema(attr, options = {}) {
+  const { isUpdate = false } = options;
+  let schema = buildBaseSchema(attr, options);
+  if (!schema) {
+    return { schema: "", skip: true, skipReason: "Unsupported type" };
+  }
+  if (isUpdate || !attr.required) {
+    schema = `${schema}.optional()`;
+  }
+  if (!isUpdate && attr.default !== void 0 && attr.default !== null) {
+    const defaultValue = formatDefaultValue(attr.default, attr.type);
+    if (defaultValue !== null) {
+      schema = `${schema}.default(${defaultValue})`;
+    }
+  }
+  return { schema, skip: false };
+}
+function buildBaseSchema(attr, options) {
+  switch (attr.type) {
+    // String types
+    case "string":
+    case "text":
+    case "richtext":
+    case "uid":
+      return buildStringSchema(attr);
+    case "email":
+      return buildEmailSchema(attr);
+    case "password":
+      return buildPasswordSchema(attr);
+    // Blocks (Strapi v5 rich text)
+    // Uses structured schema with all block types: paragraph, heading, list, quote, code, image
+    case "blocks":
+      return getCompactBlocksSchema();
+    // Number types
+    case "integer":
+    case "biginteger":
+      return buildIntegerSchema(attr);
+    case "float":
+    case "decimal":
+      return buildFloatSchema(attr);
+    // Boolean
+    case "boolean":
+      return "z.boolean()";
+    // Date types
+    case "date":
+      return "z.string().date()";
+    case "time":
+      return "z.string().time()";
+    case "datetime":
+    case "timestamp":
+      return "z.string().datetime({ offset: true })";
+    // JSON
+    case "json":
+      return "z.record(z.unknown())";
+    // Enumeration
+    case "enumeration":
+      return buildEnumSchema(attr);
+    // Media - accepts file IDs (numbers) from upload API
+    case "media":
+      return buildMediaSchema(attr);
+    // Relation - accepts documentIds (v5) or ids (v4)
+    case "relation":
+      return buildRelationSchema(attr, options);
+    // Component
+    case "component":
+      return buildComponentSchema(attr, options);
+    // Dynamic zone
+    case "dynamiczone":
+      return buildDynamicZoneSchema(attr, options);
+    default:
+      return "z.unknown()";
+  }
+}
+function buildStringSchema(attr) {
+  const parts = ["z.string()"];
+  if (attr.minLength !== void 0) {
+    parts.push(`.min(${attr.minLength})`);
+  }
+  if (attr.maxLength !== void 0) {
+    parts.push(`.max(${attr.maxLength})`);
+  }
+  if (attr.regex) {
+    const escapedRegex = attr.regex.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    parts.push(`.regex(new RegExp('${escapedRegex}'))`);
+  }
+  return parts.join("");
+}
+function buildEmailSchema(attr) {
+  let schema = "z.string().email()";
+  if (attr.minLength !== void 0) {
+    schema += `.min(${attr.minLength})`;
+  }
+  if (attr.maxLength !== void 0) {
+    schema += `.max(${attr.maxLength})`;
+  }
+  return schema;
+}
+function buildPasswordSchema(attr) {
+  let schema = "z.string()";
+  const minLength = attr.minLength ?? 6;
+  schema += `.min(${minLength})`;
+  if (attr.maxLength !== void 0) {
+    schema += `.max(${attr.maxLength})`;
+  }
+  return schema;
+}
+function buildIntegerSchema(attr) {
+  const parts = ["z.number().int()"];
+  if (attr.min !== void 0) {
+    parts.push(`.min(${attr.min})`);
+  }
+  if (attr.max !== void 0) {
+    parts.push(`.max(${attr.max})`);
+  }
+  return parts.join("");
+}
+function buildFloatSchema(attr) {
+  const parts = ["z.number()"];
+  if (attr.min !== void 0) {
+    parts.push(`.min(${attr.min})`);
+  }
+  if (attr.max !== void 0) {
+    parts.push(`.max(${attr.max})`);
+  }
+  return parts.join("");
+}
+function buildEnumSchema(attr) {
+  if (!attr.enum || attr.enum.length === 0) {
+    return "z.string()";
+  }
+  const enumValues = attr.enum.map((v) => `'${v}'`).join(", ");
+  return `z.enum([${enumValues}])`;
+}
+function buildMediaSchema(attr) {
+  if (attr.multiple) {
+    return "z.array(z.number().int().positive()).default([])";
+  }
+  return "z.number().int().positive().nullable()";
+}
+function buildRelationSchema(attr, options = {}) {
+  const isMany = attr.relation === "oneToMany" || attr.relation === "manyToMany";
+  const isV5 = options.strapiVersion !== "v4";
+  const useAdvanced = options.useAdvancedRelations && isV5;
+  const idSchema = isV5 ? "z.string()" : "z.number().int().positive()";
+  if (useAdvanced) {
+    const positionSchema = `z.object({
+    before: z.string().optional(),
+    after: z.string().optional(),
+    start: z.boolean().optional(),
+    end: z.boolean().optional(),
+  }).optional()`;
+    const relationItemSchema = `z.object({
+    documentId: ${idSchema},
+    /** Locale for i18n content types */
+    locale: z.string().optional(),
+    /** Target draft or published version */
+    status: z.enum(['draft', 'published']).optional(),
+    /** Position for ordering */
+    position: ${positionSchema},
+  })`;
+    const itemOrIdSchema = `z.union([${idSchema}, ${relationItemSchema}])`;
+    const disconnectItemSchema = `z.union([
+    ${idSchema},
+    z.object({
+      documentId: ${idSchema},
+      locale: z.string().optional(),
+      status: z.enum(['draft', 'published']).optional(),
+    })
+  ])`;
+    return `z.union([
+  // Shorthand: array of documentIds (equivalent to set)
+  z.array(${idSchema}),
+  // Longhand: object with connect/disconnect/set
+  z.object({
+    /** Add relations while preserving existing ones */
+    connect: z.array(${itemOrIdSchema}).optional(),
+    /** Remove specific relations */
+    disconnect: z.array(${disconnectItemSchema}).optional(),
+    /** Replace ALL relations (cannot combine with connect/disconnect) */
+    set: z.array(${itemOrIdSchema}).optional(),
+  })
+]).optional()`;
+  }
+  if (isMany) {
+    return `z.array(${idSchema}).default([])`;
+  }
+  return `${idSchema}.nullable()`;
+}
+function buildComponentSchema(attr, options = {}) {
+  const schemaName = options.componentSchemaNames?.get(attr.component);
+  if (schemaName) {
+    if (attr.repeatable) {
+      return `z.array(${schemaName})`;
+    }
+    return `${schemaName}.nullable()`;
+  }
+  if (attr.repeatable) {
+    return "z.array(z.record(z.unknown()))";
+  }
+  return "z.record(z.unknown()).nullable()";
+}
+function buildDynamicZoneSchema(attr, options = {}) {
+  if (options.componentSchemaNames && attr.components && attr.components.length > 0) {
+    const members = attr.components.map((uid) => {
+      const schemaName = options.componentSchemaNames.get(uid);
+      if (!schemaName) return null;
+      return `${schemaName}.extend({ __component: z.literal('${uid}') })`;
+    }).filter(Boolean);
+    if (members.length > 0) {
+      return `z.array(
+  z.discriminatedUnion('__component', [
+    ${members.join(",\n    ")},
+  ])
+)`;
+    }
+  }
+  return "z.array(z.record(z.unknown()))";
+}
+function formatDefaultValue(value, type) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (type) {
+    case "string":
+    case "text":
+    case "richtext":
+    case "email":
+    case "uid":
+      return typeof value === "string" ? `'${value.replace(/'/g, "\\'")}'` : null;
+    case "integer":
+    case "biginteger":
+    case "float":
+    case "decimal":
+      return typeof value === "number" ? String(value) : null;
+    case "boolean":
+      return typeof value === "boolean" ? String(value) : null;
+    case "enumeration":
+      return typeof value === "string" ? `'${value}'` : null;
+    default:
+      return null;
+  }
+}
+function generateZodObjectSchema(attributes, options = {}) {
+  const fields = [];
+  const skippedFields = [];
+  for (const [name, attr] of Object.entries(attributes)) {
+    if (isSystemField(name)) {
+      continue;
+    }
+    if (attr.private) {
+      skippedFields.push({ name, reason: "Private field" });
+      continue;
+    }
+    const mapped = mapAttributeToZodSchema(attr, options);
+    if (mapped.skip) {
+      skippedFields.push({ name, reason: mapped.skipReason || "Unknown" });
+      continue;
+    }
+    fields.push(`  ${name}: ${mapped.schema},`);
+  }
+  const schema = `z.object({
+${fields.join("\n")}
+})`;
+  return { schema, skippedFields };
+}
+
+// src/frameworks/astro/actions.ts
 function isAstroActionsSupported(astroVersion) {
   if (!astroVersion) return false;
   const match = astroVersion.replace(/^[\^~]/, "").match(/^(\d+)/);
@@ -1483,26 +1780,26 @@ function isAstroActionsSupported(astroVersion) {
   return majorVersion !== null && majorVersion >= 4;
 }
 async function generateAstroActions(schema, options) {
-  const { outputDir, servicesImportPath, strapiVersion = "v5" } = options;
+  const { outputDir, servicesImportPath, strapiVersion = "v5", useTypedSchemas = true } = options;
   const generatedFiles = [];
   await ensureDir(outputDir);
   for (const collection of schema.collections) {
     const fileName = `${toKebabCase(collection.singularName)}.ts`;
     const filePath = path9.join(outputDir, fileName);
-    const content = generateCollectionActions(collection, servicesImportPath, strapiVersion);
+    const content = generateCollectionActions(collection, servicesImportPath, strapiVersion, useTypedSchemas);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
   }
   for (const single of schema.singles) {
     const fileName = `${toKebabCase(single.singularName)}.ts`;
     const filePath = path9.join(outputDir, fileName);
-    const content = generateSingleActions(single, servicesImportPath);
+    const content = generateSingleActions(single, servicesImportPath, useTypedSchemas);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
   }
   return generatedFiles;
 }
-function generateCollectionActions(collection, servicesImportPath, strapiVersion) {
+function generateCollectionActions(collection, servicesImportPath, strapiVersion, useTypedSchemas = false) {
   const serviceName = toCamelCase(collection.singularName) + "Service";
   const actionsName = toCamelCase(collection.singularName);
   const fileName = toKebabCase(collection.singularName);
@@ -1511,6 +1808,26 @@ function generateCollectionActions(collection, servicesImportPath, strapiVersion
   const idParamName = isV4 ? "id" : "documentId";
   const idComment = isV4 ? "id" : "documentId";
   const hasSlug = "slug" in collection.attributes;
+  let createDataSchema = "z.record(z.unknown())";
+  let updateDataSchema = "z.record(z.unknown())";
+  let schemaDefinitions = "";
+  if (useTypedSchemas) {
+    const createResult = generateZodObjectSchema(collection.attributes, { isUpdate: false });
+    const updateResult = generateZodObjectSchema(collection.attributes, { isUpdate: true });
+    schemaDefinitions = `
+/**
+ * Create schema for ${collection.displayName}
+ */
+const createSchema = ${createResult.schema};
+
+/**
+ * Update schema for ${collection.displayName}
+ */
+const updateSchema = ${updateResult.schema};
+`;
+    createDataSchema = "createSchema";
+    updateDataSchema = "updateSchema";
+  }
   return `/**
  * ${collection.displayName} Actions
  * ${collection.description || ""}
@@ -1530,6 +1847,7 @@ const paginationSchema = z.object({
   page: z.number().int().positive().optional().default(1),
   pageSize: z.number().int().positive().max(100).optional().default(25),
 }).optional();
+${schemaDefinitions}
 
 /**
  * ${collection.displayName} actions
@@ -1625,7 +1943,7 @@ ${hasSlug ? `
    */
   create: defineAction({
     input: z.object({
-      data: z.record(z.unknown()),
+      data: ${createDataSchema},
     }),
     handler: async ({ data }) => {
       try {
@@ -1646,7 +1964,7 @@ ${hasSlug ? `
   update: defineAction({
     input: z.object({
       ${idParamName}: ${idInputSchema},
-      data: z.record(z.unknown()),
+      data: ${updateDataSchema},
     }),
     handler: async ({ ${idParamName}, data }) => {
       try {
@@ -1703,10 +2021,22 @@ ${hasSlug ? `
 };
 `;
 }
-function generateSingleActions(single, servicesImportPath) {
+function generateSingleActions(single, servicesImportPath, useTypedSchemas = false) {
   const serviceName = toCamelCase(single.singularName) + "Service";
   const actionsName = toCamelCase(single.singularName);
   const fileName = toKebabCase(single.singularName);
+  let updateDataSchema = "z.record(z.unknown())";
+  let schemaDefinitions = "";
+  if (useTypedSchemas) {
+    const updateResult = generateZodObjectSchema(single.attributes, { isUpdate: true });
+    schemaDefinitions = `
+/**
+ * Update schema for ${single.displayName}
+ */
+const updateSchema = ${updateResult.schema};
+`;
+    updateDataSchema = "updateSchema";
+  }
   return `/**
  * ${single.displayName} Actions (Single Type)
  * ${single.description || ""}
@@ -1717,7 +2047,7 @@ function generateSingleActions(single, servicesImportPath) {
 import { defineAction, ActionError } from 'astro:actions';
 import { z } from 'astro:schema';
 import { ${serviceName} } from '${servicesImportPath}/${fileName}.service';
-
+${schemaDefinitions}
 /**
  * ${single.displayName} actions
  */
@@ -1758,7 +2088,7 @@ export const ${actionsName} = {
    */
   update: defineAction({
     input: z.object({
-      data: z.record(z.unknown()),
+      data: ${updateDataSchema},
     }),
     handler: async ({ data }) => {
       try {
@@ -1806,23 +2136,20 @@ function generateV5ClientFile(apiPrefix) {
   return `/**
  * Strapi Client (v5)
  * Generated by strapi2front
+ *
+ * Using official @strapi/client
+ * @see https://docs.strapi.io/cms/api/client
  */
 
-import Strapi from 'strapi-sdk-js';
+import { strapi } from '@strapi/client';
 
 // Initialize the Strapi client
-const strapiUrl = import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337';
-const strapiToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
-const strapiApiPrefix = import.meta.env.STRAPI_API_PREFIX || process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
-
-export const strapi = new Strapi({
-  url: strapiUrl,
-  prefix: strapiApiPrefix,
-  axiosOptions: {
-    headers: strapiToken ? {
-      Authorization: \`Bearer \${strapiToken}\`,
-    } : {},
-  },
+const baseURL = (import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337') + '${normalizedPrefix}';
+const authToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
+
+export const strapiClient = strapi({
+  baseURL,
+  auth: authToken,
 });
 
 // Pagination type
@@ -1833,6 +2160,53 @@ export interface StrapiPagination {
   total: number;
 }
 
+// Media types
+export interface StrapiMediaFormat {
+  name: string;
+  hash: string;
+  ext: string;
+  mime: string;
+  width: number;
+  height: number;
+  size: number;
+  url: string;
+}
+
+export interface StrapiMedia {
+  id: number;
+  documentId: string;
+  name: string;
+  alternativeText: string | null;
+  caption: string | null;
+  width: number;
+  height: number;
+  formats: {
+    thumbnail?: StrapiMediaFormat;
+    small?: StrapiMediaFormat;
+    medium?: StrapiMediaFormat;
+    large?: StrapiMediaFormat;
+  } | null;
+  hash: string;
+  ext: string;
+  mime: string;
+  size: number;
+  url: string;
+  previewUrl: string | null;
+  provider: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * File metadata for uploads
+ * @see https://docs.strapi.io/cms/api/client#upload
+ */
+export interface StrapiFileInfo {
+  name?: string;
+  alternativeText?: string;
+  caption?: string;
+}
+
 // Default pagination for fallback
 const defaultPagination: StrapiPagination = {
   page: 1,
@@ -1841,24 +2215,12 @@ const defaultPagination: StrapiPagination = {
   total: 0,
 };
 
-// Response types
-interface StrapiListResponse<T> {
-  data: T[];
-  meta: {
-    pagination?: StrapiPagination;
-  };
-}
-
-interface StrapiSingleResponse<T> {
-  data: T;
-  meta?: Record<string, unknown>;
-}
-
 // Helper to get typed collection
 export function collection<T>(pluralName: string) {
+  const col = strapiClient.collection(pluralName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T[]; meta: { pagination: StrapiPagination } }> {
-      const response = await strapi.find(pluralName, params) as unknown as StrapiListResponse<T>;
+      const response = await col.find(params) as any;
       return {
         data: Array.isArray(response.data) ? response.data : [],
         meta: {
@@ -1867,39 +2229,68 @@ export function collection<T>(pluralName: string) {
       };
     },
     async findOne(documentId: string, params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.findOne(pluralName, documentId, params) as unknown as StrapiSingleResponse<T>;
+      const response = await col.findOne(documentId, params) as any;
       return { data: response.data };
     },
-    async create(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.create(pluralName, data.data as Record<string, unknown>) as unknown as StrapiSingleResponse<T>;
+    async create(data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.create(data as any) as any;
       return { data: response.data };
     },
-    async update(documentId: string, data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(pluralName, documentId, data.data as Record<string, unknown>) as unknown as StrapiSingleResponse<T>;
+    async update(documentId: string, data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.update(documentId, data as any) as any;
       return { data: response.data };
     },
     async delete(documentId: string): Promise<void> {
-      await strapi.delete(pluralName, documentId);
+      await col.delete(documentId);
     },
   };
 }
 
 // Helper to get typed single type
 export function single<T>(singularName: string) {
+  const singleType = strapiClient.single(singularName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.find(singularName, params) as unknown as StrapiSingleResponse<T>;
+      const response = await singleType.find(params) as any;
       return { data: response.data };
     },
-    async update(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(singularName, 1 as unknown as string, data.data as Record<string, unknown>) as unknown as StrapiSingleResponse<T>;
+    async update(data: Partial<T>): Promise<{ data: T }> {
+      const response = await singleType.update(data as any) as any;
       return { data: response.data };
     },
     async delete(): Promise<void> {
-      await strapi.delete(singularName, 1 as unknown as string);
+      await singleType.delete();
     },
   };
 }
+
+/**
+ * File management helpers
+ * Wraps @strapi/client file methods with proper typing
+ * @see https://docs.strapi.io/cms/api/client#working-with-files
+ */
+export const files = {
+  async upload(file: File | Blob, options?: { fileInfo?: StrapiFileInfo }): Promise<StrapiMedia> {
+    const response = await strapiClient.files.upload(file, options) as any;
+    return response;
+  },
+  async find(params?: Record<string, unknown>): Promise<StrapiMedia[]> {
+    const response = await strapiClient.files.find(params) as any;
+    return Array.isArray(response) ? response : [];
+  },
+  async findOne(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.findOne(fileId) as any;
+    return response;
+  },
+  async update(fileId: number, fileInfo: StrapiFileInfo): Promise<StrapiMedia> {
+    const response = await strapiClient.files.update(fileId, fileInfo) as any;
+    return response;
+  },
+  async delete(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.delete(fileId) as any;
+    return response;
+  },
+};
 `;
 }
 function generateV4ClientFile(apiPrefix) {
@@ -1907,23 +2298,20 @@ function generateV4ClientFile(apiPrefix) {
   return `/**
  * Strapi Client (v4)
  * Generated by strapi2front
+ *
+ * Note: @strapi/client officially supports Strapi v5+
+ * This v4 client uses a compatibility layer for the nested attributes structure
  */
 
-import Strapi from 'strapi-sdk-js';
+import { strapi as createStrapi } from '@strapi/client';
 
 // Initialize the Strapi client
-const strapiUrl = import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337';
-const strapiToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
-const strapiApiPrefix = import.meta.env.STRAPI_API_PREFIX || process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
-
-export const strapi = new Strapi({
-  url: strapiUrl,
-  prefix: strapiApiPrefix,
-  axiosOptions: {
-    headers: strapiToken ? {
-      Authorization: \`Bearer \${strapiToken}\`,
-    } : {},
-  },
+const baseURL = (import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337') + '${normalizedPrefix}';
+const authToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
+
+export const strapiClient = createStrapi({
+  baseURL,
+  auth: authToken,
 });
 
 // Pagination type
@@ -1934,6 +2322,52 @@ export interface StrapiPagination {
   total: number;
 }
 
+// Media types
+export interface StrapiMediaFormat {
+  name: string;
+  hash: string;
+  ext: string;
+  mime: string;
+  width: number;
+  height: number;
+  size: number;
+  url: string;
+}
+
+export interface StrapiMedia {
+  id: number;
+  name: string;
+  alternativeText: string | null;
+  caption: string | null;
+  width: number;
+  height: number;
+  formats: {
+    thumbnail?: StrapiMediaFormat;
+    small?: StrapiMediaFormat;
+    medium?: StrapiMediaFormat;
+    large?: StrapiMediaFormat;
+  } | null;
+  hash: string;
+  ext: string;
+  mime: string;
+  size: number;
+  url: string;
+  previewUrl: string | null;
+  provider: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * File metadata for uploads
+ * @see https://docs.strapi.io/cms/api/client#upload
+ */
+export interface StrapiFileInfo {
+  name?: string;
+  alternativeText?: string;
+  caption?: string;
+}
+
 // Default pagination for fallback
 const defaultPagination: StrapiPagination = {
   page: 1,
@@ -1948,18 +2382,6 @@ interface StrapiV4RawItem<T> {
   attributes: Omit<T, 'id'>;
 }
 
-interface StrapiV4RawListResponse<T> {
-  data: StrapiV4RawItem<T>[];
-  meta: {
-    pagination?: StrapiPagination;
-  };
-}
-
-interface StrapiV4RawSingleResponse<T> {
-  data: StrapiV4RawItem<T>;
-  meta?: Record<string, unknown>;
-}
-
 /**
  * Flatten a Strapi v4 response item (merges id with attributes)
  */
@@ -2003,55 +2425,83 @@ function flattenRelations<T>(data: T): T {
   return data;
 }
 
-// Helper to get typed collection
+// Helper to get typed collection (v4 compatibility wrapper)
 export function collection<T>(pluralName: string) {
+  const col = strapiClient.collection(pluralName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T[]; meta: { pagination: StrapiPagination } }> {
-      const response = await strapi.find(pluralName, params) as unknown as StrapiV4RawListResponse<T>;
+      const response = await col.find(params) as any;
       const flattenedData = Array.isArray(response.data)
-        ? response.data.map(item => flattenRelations(flattenItem<T>(item)))
+        ? response.data.map((item: StrapiV4RawItem<T>) => flattenRelations(flattenItem<T>(item)))
         : [];
       return {
         data: flattenedData,
-        meta: {
-          pagination: response.meta?.pagination || defaultPagination,
-        },
+        meta: { pagination: response.meta?.pagination || defaultPagination },
       };
     },
     async findOne(id: number | string, params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.findOne(pluralName, String(id), params) as unknown as StrapiV4RawSingleResponse<T>;
+      const response = await col.findOne(String(id), params) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
-    async create(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.create(pluralName, data.data as Record<string, unknown>) as unknown as StrapiV4RawSingleResponse<T>;
+    async create(data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.create(data as any) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
-    async update(id: number | string, data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(pluralName, String(id), data.data as Record<string, unknown>) as unknown as StrapiV4RawSingleResponse<T>;
+    async update(id: number | string, data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.update(String(id), data as any) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
     async delete(id: number | string): Promise<void> {
-      await strapi.delete(pluralName, String(id));
+      await col.delete(String(id));
     },
   };
 }
 
-// Helper to get typed single type
+// Helper to get typed single type (v4 compatibility wrapper)
 export function single<T>(singularName: string) {
+  const singleType = strapiClient.single(singularName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.find(singularName, params) as unknown as StrapiV4RawSingleResponse<T>;
+      const response = await singleType.find(params) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
-    async update(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(singularName, 1 as unknown as string, data.data as Record<string, unknown>) as unknown as StrapiV4RawSingleResponse<T>;
+    async update(data: Partial<T>): Promise<{ data: T }> {
+      const response = await singleType.update(data as any) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
     async delete(): Promise<void> {
-      await strapi.delete(singularName, 1 as unknown as string);
+      await singleType.delete();
     },
   };
 }
+
+/**
+ * File management helpers
+ * Wraps @strapi/client file methods with proper typing
+ * @see https://docs.strapi.io/cms/api/client#working-with-files
+ */
+export const files = {
+  async upload(file: File | Blob, options?: { fileInfo?: StrapiFileInfo }): Promise<StrapiMedia> {
+    const response = await strapiClient.files.upload(file, options) as any;
+    return response;
+  },
+  async find(params?: Record<string, unknown>): Promise<StrapiMedia[]> {
+    const response = await strapiClient.files.find(params) as any;
+    return Array.isArray(response) ? response : [];
+  },
+  async findOne(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.findOne(fileId) as any;
+    return response;
+  },
+  async update(fileId: number, fileInfo: StrapiFileInfo): Promise<StrapiMedia> {
+    const response = await strapiClient.files.update(fileId, fileInfo) as any;
+    return response;
+  },
+  async delete(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.delete(fileId) as any;
+    return response;
+  },
+};
 `;
 }
 async function generateLocales(locales, options) {
@@ -2132,6 +2582,7 @@ async function generateByFeature(schema, locales, options) {
   const {
     outputDir,
     features,
+    schemaOptions = {},
     blocksRendererInstalled = false,
     strapiVersion = "v5",
     apiPrefix = "/api",
@@ -2139,8 +2590,10 @@ async function generateByFeature(schema, locales, options) {
     moduleType = "commonjs"
   } = options;
   const generatedFiles = [];
+  const advancedRelations = schemaOptions.advancedRelations ?? false;
   const useESM = outputFormat === "jsdoc" && moduleType === "esm";
   const ext = outputFormat === "jsdoc" ? "js" : "ts";
+  const generateSchemas = features.schemas ?? outputFormat === "typescript";
   await ensureDir(path9.join(outputDir, "collections"));
   await ensureDir(path9.join(outputDir, "singles"));
   await ensureDir(path9.join(outputDir, "components"));
@@ -2158,6 +2611,18 @@ async function generateByFeature(schema, locales, options) {
   const localesContent = outputFormat === "jsdoc" ? generateLocalesFileJSDoc(locales, useESM) : generateLocalesFile2(locales);
   await writeFile(localesPath, await formatCode(localesContent));
   generatedFiles.push(localesPath);
+  if (features.upload) {
+    const uploadClientPath = path9.join(sharedDir, `upload-client.${ext}`);
+    const uploadClientContent = outputFormat === "jsdoc" ? generateUploadClientJSDoc(useESM) : generateUploadClientTS();
+    await writeFile(uploadClientPath, await formatCode(uploadClientContent));
+    generatedFiles.push(uploadClientPath);
+    if (features.actions && outputFormat === "typescript") {
+      const uploadActionPath = path9.join(sharedDir, "upload-action.ts");
+      const uploadActionContent = generateUploadActionTS();
+      await writeFile(uploadActionPath, await formatCode(uploadActionContent));
+      generatedFiles.push(uploadActionPath);
+    }
+  }
   for (const collection of schema.collections) {
     const featureDir = path9.join(outputDir, "collections", toKebabCase(collection.singularName));
     await ensureDir(featureDir);
@@ -2167,6 +2632,12 @@ async function generateByFeature(schema, locales, options) {
       await writeFile(typesPath, await formatCode(content));
       generatedFiles.push(typesPath);
     }
+    if (generateSchemas) {
+      const schemasPath = path9.join(featureDir, `schemas.${ext}`);
+      const schemasContent = generateCollectionSchemas(collection, schema, strapiVersion, advancedRelations);
+      await writeFile(schemasPath, await formatCode(schemasContent));
+      generatedFiles.push(schemasPath);
+    }
     if (features.services) {
       const servicePath = path9.join(featureDir, `service.${ext}`);
       const content = outputFormat === "jsdoc" ? generateCollectionServiceJSDoc(collection, strapiVersion, useESM) : generateCollectionService3(collection, strapiVersion);
@@ -2175,7 +2646,12 @@ async function generateByFeature(schema, locales, options) {
     }
     if (features.actions) {
       const actionsPath = path9.join(featureDir, `actions.${ext}`);
-      await writeFile(actionsPath, await formatCode(generateCollectionActions2(collection, strapiVersion)));
+      const actionsContent = generateCollectionActions2(collection, {
+        strapiVersion,
+        useExternalSchemas: generateSchemas,
+        draftAndPublish: collection.draftAndPublish
+      });
+      await writeFile(actionsPath, await formatCode(actionsContent));
       generatedFiles.push(actionsPath);
     }
   }
@@ -2188,6 +2664,12 @@ async function generateByFeature(schema, locales, options) {
       await writeFile(typesPath, await formatCode(content));
       generatedFiles.push(typesPath);
     }
+    if (generateSchemas) {
+      const schemasPath = path9.join(featureDir, `schemas.${ext}`);
+      const schemasContent = generateSingleSchemas(single, schema, strapiVersion, advancedRelations);
+      await writeFile(schemasPath, await formatCode(schemasContent));
+      generatedFiles.push(schemasPath);
+    }
     if (features.services) {
       const servicePath = path9.join(featureDir, `service.${ext}`);
       const content = outputFormat === "jsdoc" ? generateSingleServiceJSDoc(single, strapiVersion, useESM) : generateSingleService3(single, strapiVersion);
@@ -2197,7 +2679,7 @@ async function generateByFeature(schema, locales, options) {
   }
   for (const component of schema.components) {
     const componentPath = path9.join(outputDir, "components", `${toKebabCase(component.name)}.${ext}`);
-    const content = outputFormat === "jsdoc" ? generateComponentTypesJSDoc(component, schema, useESM) : generateComponentTypes(component, schema);
+    const content = outputFormat === "jsdoc" ? generateComponentTypesJSDoc(component, schema, useESM) : generateComponentTypes(component, schema, generateSchemas, strapiVersion, advancedRelations);
     await writeFile(componentPath, await formatCode(content));
     generatedFiles.push(componentPath);
   }
@@ -2334,6 +2816,16 @@ export interface StrapiMediaFormat {
   url: string;
 }
 
+/**
+ * File metadata for uploads
+ * @see https://docs.strapi.io/cms/api/client#upload
+ */
+export interface StrapiFileInfo {
+  name?: string;
+  alternativeText?: string;
+  caption?: string;
+}
+
 export interface StrapiPagination {
   page: number;
   pageSize: number;
@@ -2367,25 +2859,55 @@ function generateClient2(strapiVersion, apiPrefix = "/api") {
     return `/**
  * Strapi Client (v4)
  * Generated by strapi2front
+ *
+ * Note: @strapi/client officially supports Strapi v5+
+ * This v4 client uses a compatibility layer for the nested attributes structure
  */
 
-import Strapi from 'strapi-sdk-js';
-import type { StrapiPagination } from './utils';
+import { strapi as createStrapi } from '@strapi/client';
+import type { StrapiPagination, StrapiMedia, StrapiFileInfo } from './utils';
 
-// Initialize the Strapi client
-const strapiUrl = import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337';
-const strapiToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
-const strapiApiPrefix = import.meta.env.STRAPI_API_PREFIX || process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
-
-export const strapi = new Strapi({
-  url: strapiUrl,
-  prefix: strapiApiPrefix,
-  axiosOptions: {
-    headers: strapiToken ? {
-      Authorization: \`Bearer \${strapiToken}\`,
-    } : {},
-  },
-});
+// Default configuration from environment
+const defaultBaseURL = import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337';
+const defaultAuthToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
+const apiPrefix = '${normalizedPrefix}';
+
+/**
+ * Client options for authentication and connection
+ * @beta This API is in beta and may change
+ */
+export interface ClientOptions {
+  /** JWT token or API token for authentication */
+  authToken?: string;
+  /** Base URL of the Strapi instance (without /api prefix) */
+  baseURL?: string;
+}
+
+/**
+ * Create a configured Strapi client instance
+ *
+ * @param options - Optional configuration (authToken, baseURL)
+ * @returns Configured Strapi client
+ *
+ * @example
+ * // Default client (uses STRAPI_URL and STRAPI_TOKEN from env)
+ * const client = createStrapiClient();
+ *
+ * @example
+ * // Client with user JWT token
+ * const userClient = createStrapiClient({ authToken: session.jwt });
+ *
+ * @beta This API is in beta and may change
+ */
+export function createStrapiClient(options?: ClientOptions) {
+  const baseURL = (options?.baseURL || defaultBaseURL) + apiPrefix;
+  const auth = options?.authToken || defaultAuthToken;
+
+  return createStrapi({ baseURL, auth });
+}
+
+// Default client instance (uses environment variables)
+export const strapiClient = createStrapiClient();
 
 // Default pagination for fallback
 const defaultPagination: StrapiPagination = {
@@ -2401,18 +2923,6 @@ interface StrapiV4RawItem<T> {
   attributes: Omit<T, 'id'>;
 }
 
-interface StrapiV4RawListResponse<T> {
-  data: StrapiV4RawItem<T>[];
-  meta: {
-    pagination?: StrapiPagination;
-  };
-}
-
-interface StrapiV4RawSingleResponse<T> {
-  data: StrapiV4RawItem<T>;
-  meta?: Record<string, unknown>;
-}
-
 /**
  * Flatten a Strapi v4 response item (merges id with attributes)
  */
@@ -2431,18 +2941,15 @@ function flattenRelations<T>(data: T): T {
   if (typeof data === 'object') {
     const result: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
-      // Check if this is a Strapi v4 relation response { data: { id, attributes } }
       if (value && typeof value === 'object' && 'data' in value) {
         const relationData = (value as { data: unknown }).data;
         if (relationData === null) {
           result[key] = null;
         } else if (Array.isArray(relationData)) {
-          // To-many relation
           result[key] = relationData.map((item: StrapiV4RawItem<unknown>) =>
             flattenRelations(flattenItem(item))
           );
         } else if (typeof relationData === 'object' && 'id' in relationData && 'attributes' in relationData) {
-          // To-one relation
           result[key] = flattenRelations(flattenItem(relationData as StrapiV4RawItem<unknown>));
         } else {
           result[key] = flattenRelations(value);
@@ -2456,79 +2963,187 @@ function flattenRelations<T>(data: T): T {
   return data;
 }
 
-// Helper to get typed collection
-export function collection<T>(pluralName: string) {
+/**
+ * Get or create a Strapi client based on options
+ * @internal
+ */
+function getClient(options?: ClientOptions) {
+  if (options?.authToken || options?.baseURL) {
+    return createStrapiClient(options);
+  }
+  return strapiClient;
+}
+
+/**
+ * Helper to get typed collection (v4 compatibility wrapper)
+ *
+ * @param pluralName - The plural name of the collection (e.g., 'articles')
+ * @param clientOptions - Optional client configuration
+ */
+export function collection<T>(pluralName: string, clientOptions?: ClientOptions) {
+  const client = getClient(clientOptions);
+  const col = client.collection(pluralName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T[]; meta: { pagination: StrapiPagination } }> {
-      const response = await strapi.find(pluralName, params) as unknown as StrapiV4RawListResponse<T>;
+      const response = await col.find(params) as any;
       const flattenedData = Array.isArray(response.data)
-        ? response.data.map(item => flattenRelations(flattenItem<T>(item)))
+        ? response.data.map((item: StrapiV4RawItem<T>) => flattenRelations(flattenItem<T>(item)))
         : [];
       return {
         data: flattenedData,
-        meta: {
-          pagination: response.meta?.pagination || defaultPagination,
-        },
+        meta: { pagination: response.meta?.pagination || defaultPagination },
       };
     },
     async findOne(id: number | string, params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.findOne(pluralName, String(id), params) as unknown as StrapiV4RawSingleResponse<T>;
+      const response = await col.findOne(String(id), params) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
-    async create(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.create(pluralName, data.data as Record<string, unknown>) as unknown as StrapiV4RawSingleResponse<T>;
+    async create(data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.create(data as any) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
-    async update(id: number | string, data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(pluralName, String(id), data.data as Record<string, unknown>) as unknown as StrapiV4RawSingleResponse<T>;
+    async update(id: number | string, data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.update(String(id), data as any) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
     async delete(id: number | string): Promise<void> {
-      await strapi.delete(pluralName, String(id));
+      await col.delete(String(id));
     },
   };
 }
 
-// Helper to get typed single type
-export function single<T>(singularName: string) {
+/**
+ * Helper to get typed single type (v4 compatibility wrapper)
+ *
+ * @param singularName - The singular name of the single type (e.g., 'homepage')
+ * @param clientOptions - Optional client configuration
+ */
+export function single<T>(singularName: string, clientOptions?: ClientOptions) {
+  const client = getClient(clientOptions);
+  const singleType = client.single(singularName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.find(singularName, params) as unknown as StrapiV4RawSingleResponse<T>;
+      const response = await singleType.find(params) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
-    async update(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(singularName, 1 as unknown as string, data.data as Record<string, unknown>) as unknown as StrapiV4RawSingleResponse<T>;
+    async update(data: Partial<T>): Promise<{ data: T }> {
+      const response = await singleType.update(data as any) as any;
       return { data: flattenRelations(flattenItem<T>(response.data)) };
     },
     async delete(): Promise<void> {
-      await strapi.delete(singularName, 1 as unknown as string);
+      await singleType.delete();
     },
   };
 }
+
+/**
+ * File management helpers
+ * Wraps @strapi/client file methods with proper typing
+ * @see https://docs.strapi.io/cms/api/client#working-with-files
+ */
+export const files = {
+  /**
+   * Upload a file to Strapi
+   * @see https://docs.strapi.io/cms/api/client#upload
+   */
+  async upload(file: File | Blob, options?: { fileInfo?: StrapiFileInfo }): Promise<StrapiMedia> {
+    const response = await strapiClient.files.upload(file, options) as any;
+    return response;
+  },
+
+  /**
+   * Find files with optional filtering and sorting
+   */
+  async find(params?: Record<string, unknown>): Promise<StrapiMedia[]> {
+    const response = await strapiClient.files.find(params) as any;
+    return Array.isArray(response) ? response : [];
+  },
+
+  /**
+   * Get a single file by ID
+   */
+  async findOne(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.findOne(fileId) as any;
+    return response;
+  },
+
+  /**
+   * Update file metadata (name, alternativeText, caption)
+   */
+  async update(fileId: number, fileInfo: StrapiFileInfo): Promise<StrapiMedia> {
+    const response = await strapiClient.files.update(fileId, fileInfo) as any;
+    return response;
+  },
+
+  /**
+   * Delete a file by ID
+   */
+  async delete(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.delete(fileId) as any;
+    return response;
+  },
+};
 `;
   }
   return `/**
  * Strapi Client (v5)
  * Generated by strapi2front
+ *
+ * Using official @strapi/client
+ * @see https://docs.strapi.io/cms/api/client
  */
 
-import Strapi from 'strapi-sdk-js';
-import type { StrapiPagination } from './utils';
+import { strapi } from '@strapi/client';
+import type { StrapiPagination, StrapiMedia, StrapiFileInfo } from './utils';
 
-// Initialize the Strapi client
-const strapiUrl = import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337';
-const strapiToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
-const strapiApiPrefix = import.meta.env.STRAPI_API_PREFIX || process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
-
-export const strapi = new Strapi({
-  url: strapiUrl,
-  prefix: strapiApiPrefix,
-  axiosOptions: {
-    headers: strapiToken ? {
-      Authorization: \`Bearer \${strapiToken}\`,
-    } : {},
-  },
-});
+// Default configuration from environment
+const defaultBaseURL = import.meta.env.STRAPI_URL || process.env.STRAPI_URL || 'http://localhost:1337';
+const defaultAuthToken = import.meta.env.STRAPI_TOKEN || process.env.STRAPI_TOKEN;
+const apiPrefix = '${normalizedPrefix}';
+
+/**
+ * Client options for authentication and connection
+ * @beta This API is in beta and may change
+ */
+export interface ClientOptions {
+  /** JWT token or API token for authentication */
+  authToken?: string;
+  /** Base URL of the Strapi instance (without /api prefix) */
+  baseURL?: string;
+}
+
+/**
+ * Create a configured Strapi client instance
+ *
+ * @param options - Optional configuration (authToken, baseURL)
+ * @returns Configured Strapi client
+ *
+ * @example
+ * // Default client (uses STRAPI_URL and STRAPI_TOKEN from env)
+ * const client = createStrapiClient();
+ *
+ * @example
+ * // Client with user JWT token
+ * const userClient = createStrapiClient({ authToken: session.jwt });
+ *
+ * @example
+ * // Client with custom URL (multi-tenant)
+ * const tenantClient = createStrapiClient({
+ *   baseURL: 'https://tenant.example.com',
+ *   authToken: tenantToken
+ * });
+ *
+ * @beta This API is in beta and may change
+ */
+export function createStrapiClient(options?: ClientOptions) {
+  const baseURL = (options?.baseURL || defaultBaseURL) + apiPrefix;
+  const auth = options?.authToken || defaultAuthToken;
+
+  return strapi({ baseURL, auth });
+}
+
+// Default client instance (uses environment variables)
+export const strapiClient = createStrapiClient();
 
 // Default pagination for fallback
 const defaultPagination: StrapiPagination = {
@@ -2538,65 +3153,146 @@ const defaultPagination: StrapiPagination = {
   total: 0,
 };
 
-// Response types from strapi-sdk-js
-interface StrapiListResponse<T> {
-  data: T[];
-  meta: {
-    pagination?: StrapiPagination;
-  };
-}
-
-interface StrapiSingleResponse<T> {
-  data: T;
-  meta?: Record<string, unknown>;
+/**
+ * Get or create a Strapi client based on options
+ * @internal
+ */
+function getClient(options?: ClientOptions) {
+  if (options?.authToken || options?.baseURL) {
+    return createStrapiClient(options);
+  }
+  return strapiClient;
 }
 
-// Helper to get typed collection
-export function collection<T>(pluralName: string) {
+/**
+ * Helper to get typed collection
+ * Wraps @strapi/client collection methods with proper typing
+ *
+ * @param pluralName - The plural name of the collection (e.g., 'articles')
+ * @param clientOptions - Optional client configuration
+ */
+export function collection<T>(pluralName: string, clientOptions?: ClientOptions) {
+  const client = getClient(clientOptions);
+  const col = client.collection(pluralName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T[]; meta: { pagination: StrapiPagination } }> {
-      const response = await strapi.find(pluralName, params) as unknown as StrapiListResponse<T>;
+      const response = await col.find(params) as any;
       return {
         data: Array.isArray(response.data) ? response.data : [],
-        meta: {
-          pagination: response.meta?.pagination || defaultPagination,
-        },
+        meta: { pagination: response.meta?.pagination || defaultPagination },
       };
     },
     async findOne(documentId: string, params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.findOne(pluralName, documentId, params) as unknown as StrapiSingleResponse<T>;
+      const response = await col.findOne(documentId, params) as any;
       return { data: response.data };
     },
-    async create(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.create(pluralName, data.data as Record<string, unknown>) as unknown as StrapiSingleResponse<T>;
+    async create(data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.create(data as any) as any;
       return { data: response.data };
     },
-    async update(documentId: string, data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(pluralName, documentId, data.data as Record<string, unknown>) as unknown as StrapiSingleResponse<T>;
+    async update(documentId: string, data: Partial<T>): Promise<{ data: T }> {
+      const response = await col.update(documentId, data as any) as any;
       return { data: response.data };
     },
     async delete(documentId: string): Promise<void> {
-      await strapi.delete(pluralName, documentId);
+      await col.delete(documentId);
     },
   };
 }
 
-// Helper to get typed single type
-export function single<T>(singularName: string) {
+/**
+ * Helper to get typed single type
+ * Wraps @strapi/client single methods with proper typing
+ *
+ * @param singularName - The singular name of the single type (e.g., 'homepage')
+ * @param clientOptions - Optional client configuration
+ */
+export function single<T>(singularName: string, clientOptions?: ClientOptions) {
+  const client = getClient(clientOptions);
+  const singleType = client.single(singularName);
   return {
     async find(params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.find(singularName, params) as unknown as StrapiSingleResponse<T>;
+      const response = await singleType.find(params) as any;
       return { data: response.data };
     },
-    async update(data: { data: Partial<T> }): Promise<{ data: T }> {
-      const response = await strapi.update(singularName, 1 as unknown as string, data.data as Record<string, unknown>) as unknown as StrapiSingleResponse<T>;
+    async update(data: Partial<T>): Promise<{ data: T }> {
+      const response = await singleType.update(data as any) as any;
       return { data: response.data };
     },
     async delete(): Promise<void> {
-      await strapi.delete(singularName, 1 as unknown as string);
+      await singleType.delete();
     },
   };
 }
+
+/**
+ * File management helpers
+ * Wraps @strapi/client file methods with proper typing
+ * @see https://docs.strapi.io/cms/api/client#working-with-files
+ */
+export const files = {
+  /**
+   * Upload a file to Strapi
+   *
+   * @example
+   * // Browser: upload from file input
+   * const file = fileInput.files[0];
+   * const uploaded = await files.upload(file, {
+   *   fileInfo: { alternativeText: 'My image', caption: 'A caption' }
+   * });
+   *
+   * @example
+   * // Use the returned ID to link to an entry
+   * await collection('articles').create({
+   *   title: 'My article',
+   *   cover: uploaded.id,
+   * });
+   *
+   * @see https://docs.strapi.io/cms/api/client#upload
+   */
+  async upload(file: File | Blob, options?: { fileInfo?: StrapiFileInfo }): Promise<StrapiMedia> {
+    const response = await strapiClient.files.upload(file, options) as any;
+    return response;
+  },
+
+  /**
+   * Find files with optional filtering and sorting
+   *
+   * @example
+   * const images = await files.find({
+   *   filters: { mime: { $contains: 'image' } },
+   *   sort: ['name:asc'],
+   * });
+   */
+  async find(params?: Record<string, unknown>): Promise<StrapiMedia[]> {
+    const response = await strapiClient.files.find(params) as any;
+    return Array.isArray(response) ? response : [];
+  },
+
+  /**
+   * Get a single file by ID
+   */
+  async findOne(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.findOne(fileId) as any;
+    return response;
+  },
+
+  /**
+   * Update file metadata (name, alternativeText, caption)
+   */
+  async update(fileId: number, fileInfo: StrapiFileInfo): Promise<StrapiMedia> {
+    const response = await strapiClient.files.update(fileId, fileInfo) as any;
+    return response;
+  },
+
+  /**
+   * Delete a file by ID
+   */
+  async delete(fileId: number): Promise<StrapiMedia> {
+    const response = await strapiClient.files.delete(fileId) as any;
+    return response;
+  },
+};
 `;
 }
 function generateLocalesFile2(locales) {
@@ -2692,11 +3388,12 @@ ${attributes}
 }
 `;
 }
-function generateComponentTypes(component, schema) {
+function generateComponentTypes(component, schema, includeSchemas = false, strapiVersion = "v5", advancedRelations = false) {
   const typeName = toPascalCase(component.name);
+  const schemaName = toCamelCase(component.name);
   const attributes = generateAttributes2(component.attributes);
   const imports = generateTypeImports(component.attributes, schema, "component");
-  return `/**
+  let content = `/**
  * ${component.displayName} component
  * Category: ${component.category}
  * ${component.description || ""}
@@ -2710,6 +3407,32 @@ export interface ${typeName} {
 ${attributes}
 }
 `;
+  if (includeSchemas) {
+    const componentSchemaNames = buildComponentSchemaNames(component.attributes, schema);
+    const schemaImports = generateSchemaImports(component.attributes, schema, "component");
+    const schemaOptions = {
+      isUpdate: false,
+      strapiVersion,
+      useAdvancedRelations: advancedRelations,
+      componentSchemaNames
+    };
+    const schemaResult = generateZodObjectSchema(component.attributes, schemaOptions);
+    content += `
+import { z } from 'zod';
+${schemaImports}
+/**
+ * Zod schema for ${component.displayName} component
+ * Use this for validating component data in forms
+ */
+export const ${schemaName}Schema = ${schemaResult.schema};
+
+/**
+ * Inferred type from schema
+ */
+export type ${typeName}Input = z.infer<typeof ${schemaName}Schema>;
+`;
+  }
+  return content;
 }
 function generateTypeImports(attributes, schema, context) {
   const utilsImports = [];
@@ -2863,7 +3586,7 @@ function generateCollectionService3(collection, strapiVersion) {
   const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt' | 'publishedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt' | 'publishedAt'";
   const omitFieldsUpdate = isV4 ? "'id' | 'createdAt' | 'updatedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt'";
   const imports = [
-    `import { collection } from '../../shared/client';`,
+    `import { collection, type ClientOptions } from '../../shared/client';`,
     `import type { ${typeName}, ${typeName}Filters } from './types';`,
     `import type { StrapiPagination } from '../../shared/utils';`
   ];
@@ -2914,6 +3637,18 @@ function generateCollectionService3(collection, strapiVersion) {
     findOneParams += `
         status: options.status,`;
   }
+  const createOptionsInterface = draftAndPublish ? `
+export interface CreateOptions {
+  /** Publish immediately or create as draft. Default: 'draft' */
+  status?: 'draft' | 'published';
+}
+` : "";
+  const updateOptionsInterface = draftAndPublish ? `
+export interface UpdateOptions {
+  /** Change publication status */
+  status?: 'draft' | 'published';
+}
+` : "";
   return `/**
  * ${collection.displayName} Service
  * ${collection.description || ""}
@@ -2930,13 +3665,24 @@ ${findManyOptionsFields}
 export interface FindOneOptions {
 ${findOneOptionsFields}
 }
-
-// Create typed collection helper
-const ${toCamelCase(collection.singularName)}Collection = collection<${typeName}>('${endpoint}');
+${createOptionsInterface}${updateOptionsInterface}
+/**
+ * Get a typed collection helper, optionally with custom client options
+ * @internal
+ */
+function getCollection(clientOptions?: ClientOptions) {
+  return collection<${typeName}>('${endpoint}', clientOptions);
+}
 
 export const ${serviceName} = {
-  async findMany(options: FindManyOptions = {}): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
-    const response = await ${toCamelCase(collection.singularName)}Collection.find({
+  /**
+   * Find multiple ${collection.displayName} entries
+   * @param options - Query options (filters, pagination, sort, populate)
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async findMany(options: FindManyOptions = {}, clientOptions?: ClientOptions): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
+    const col = getCollection(clientOptions);
+    const response = await col.find({
 ${findParams}
     });
 
@@ -2946,7 +3692,12 @@ ${findParams}
     };
   },
 
-  async findAll(options: Omit<FindManyOptions, 'pagination'> = {}): Promise<${typeName}[]> {
+  /**
+   * Find all ${collection.displayName} entries (handles pagination automatically)
+   * @param options - Query options (filters, sort, populate)
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async findAll(options: Omit<FindManyOptions, 'pagination'> = {}, clientOptions?: ClientOptions): Promise<${typeName}[]> {
     const allItems: ${typeName}[] = [];
     let page = 1;
     let hasMore = true;
@@ -2955,7 +3706,7 @@ ${findParams}
       const { data, pagination } = await this.findMany({
         ...options,
         pagination: { page, pageSize: 100 },
-      });
+      }, clientOptions);
 
       allItems.push(...data);
       hasMore = page < pagination.pageCount;
@@ -2965,9 +3716,16 @@ ${findParams}
     return allItems;
   },
 
-  async findOne(${idParam}, options: FindOneOptions = {}): Promise<${typeName} | null> {
+  /**
+   * Find a single ${collection.displayName} by ID
+   * @param ${idName} - The ${isV4 ? "numeric ID" : "document ID"}
+   * @param options - Query options (populate)
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async findOne(${idParam}, options: FindOneOptions = {}, clientOptions?: ClientOptions): Promise<${typeName} | null> {
     try {
-      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idName}, {
+      const col = getCollection(clientOptions);
+      const response = await col.findOne(${idName}, {
 ${findOneParams}
       });
 
@@ -2980,35 +3738,65 @@ ${findOneParams}
     }
   },
 ${hasSlug ? `
-  async findBySlug(slug: string, options: FindOneOptions = {}): Promise<${typeName} | null> {
+  /**
+   * Find a single ${collection.displayName} by slug
+   * @param slug - The slug value
+   * @param options - Query options (populate)
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async findBySlug(slug: string, options: FindOneOptions = {}, clientOptions?: ClientOptions): Promise<${typeName} | null> {
     const { data } = await this.findMany({
       filters: { slug: { $eq: slug } } as ${typeName}Filters,
       pagination: { pageSize: 1 },
       populate: options.populate,${localized ? "\n      locale: options.locale," : ""}${draftAndPublish ? "\n      status: options.status," : ""}
-    });
+    }, clientOptions);
 
     return data[0] || null;
   },
 ` : ""}
-  async create(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
-    const response = await ${toCamelCase(collection.singularName)}Collection.create({ data });
+  /**
+   * Create a new ${collection.displayName}
+   * @param data - The data to create
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async create(data: Partial<Omit<${typeName}, ${omitFields}>>${draftAndPublish ? ", options: CreateOptions = {}" : ""}, clientOptions?: ClientOptions): Promise<${typeName}> {
+    const col = getCollection(clientOptions);
+    const response = await col.create(${draftAndPublish ? "{ ...data, status: options.status }" : "data"});
     return response.data;
   },
 
-  async update(${idParam}, data: Partial<Omit<${typeName}, ${omitFieldsUpdate}>>): Promise<${typeName}> {
-    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idName}, { data });
+  /**
+   * Update an existing ${collection.displayName}
+   * @param ${idName} - The ${isV4 ? "numeric ID" : "document ID"}
+   * @param data - The data to update
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async update(${idParam}, data: Partial<Omit<${typeName}, ${omitFieldsUpdate}>>${draftAndPublish ? ", options: UpdateOptions = {}" : ""}, clientOptions?: ClientOptions): Promise<${typeName}> {
+    const col = getCollection(clientOptions);
+    const response = await col.update(${idName}, ${draftAndPublish ? "{ ...data, status: options.status }" : "data"});
     return response.data;
   },
 
-  async delete(${idParam}): Promise<void> {
-    await ${toCamelCase(collection.singularName)}Collection.delete(${idName});
+  /**
+   * Delete a ${collection.displayName}
+   * @param ${idName} - The ${isV4 ? "numeric ID" : "document ID"}
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async delete(${idParam}, clientOptions?: ClientOptions): Promise<void> {
+    const col = getCollection(clientOptions);
+    await col.delete(${idName});
   },
 
-  async count(filters?: ${typeName}Filters): Promise<number> {
+  /**
+   * Count ${collection.displayName} entries
+   * @param filters - Optional filters
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async count(filters?: ${typeName}Filters, clientOptions?: ClientOptions): Promise<number> {
     const { pagination } = await this.findMany({
       filters,
       pagination: { pageSize: 1 },
-    });
+    }, clientOptions);
 
     return pagination.total;
   },
@@ -3023,7 +3811,7 @@ function generateSingleService3(single, strapiVersion) {
   const isV4 = strapiVersion === "v4";
   const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt'";
   const imports = [
-    `import { single } from '../../shared/client';`,
+    `import { single, type ClientOptions } from '../../shared/client';`,
     `import type { ${typeName} } from './types';`
   ];
   if (localized) {
@@ -3060,43 +3848,208 @@ export interface FindOptions {
 ${findOptionsFields}
 }
 
-// Create typed single helper
-const ${toCamelCase(single.singularName)}Single = single<${typeName}>('${endpoint}');
+/**
+ * Get a typed single helper, optionally with custom client options
+ * @internal
+ */
+function getSingle(clientOptions?: ClientOptions) {
+  return single<${typeName}>('${endpoint}', clientOptions);
+}
 
 export const ${serviceName} = {
-  async find(options: FindOptions = {}): Promise<${typeName} | null> {
+  /**
+   * Find the ${single.displayName} single type
+   * @param options - Query options (populate)
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async find(options: FindOptions = {}, clientOptions?: ClientOptions): Promise<${typeName} | null> {
     try {
-      const response = await ${toCamelCase(single.singularName)}Single.find({
+      const s = getSingle(clientOptions);
+      const response = await s.find({
 ${findParams}
       });
 
-      return response.data;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes('404')) {
-        return null;
-      }
-      throw error;
-    }
-  },
+      return response.data;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('404')) {
+        return null;
+      }
+      throw error;
+    }
+  },
+
+  /**
+   * Update the ${single.displayName} single type
+   * @param data - The data to update
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async update(data: Partial<Omit<${typeName}, ${omitFields}>>, clientOptions?: ClientOptions): Promise<${typeName}> {
+    const s = getSingle(clientOptions);
+    const response = await s.update(data);
+    return response.data;
+  },
+
+  /**
+   * Delete the ${single.displayName} single type
+   * @param clientOptions - Optional client configuration (authToken, baseURL) - beta
+   */
+  async delete(clientOptions?: ClientOptions): Promise<void> {
+    const s = getSingle(clientOptions);
+    await s.delete();
+  },
+};
+`;
+}
+function buildComponentSchemaNames(attributes, schema) {
+  const map = /* @__PURE__ */ new Map();
+  for (const attr of Object.values(attributes)) {
+    if (attr.type === "component" && "component" in attr && attr.component) {
+      const uid = attr.component;
+      if (!map.has(uid)) {
+        const componentName = uid.split(".").pop() || "";
+        const exists = schema.components.some((c) => c.name === componentName);
+        if (exists && componentName) {
+          map.set(uid, `${toCamelCase(componentName)}Schema`);
+        }
+      }
+    }
+    if (attr.type === "dynamiczone" && "components" in attr && attr.components) {
+      for (const uid of attr.components) {
+        if (!map.has(uid)) {
+          const componentName = uid.split(".").pop() || "";
+          const exists = schema.components.some((c) => c.name === componentName);
+          if (exists && componentName) {
+            map.set(uid, `${toCamelCase(componentName)}Schema`);
+          }
+        }
+      }
+    }
+  }
+  return map;
+}
+function generateSchemaImports(attributes, schema, context) {
+  const imports = /* @__PURE__ */ new Map();
+  const relativePrefix = context === "component" ? "." : "../../components";
+  for (const attr of Object.values(attributes)) {
+    if (attr.type === "component" && "component" in attr && attr.component) {
+      addComponentImport(attr.component, imports, schema, relativePrefix);
+    }
+    if (attr.type === "dynamiczone" && "components" in attr && attr.components) {
+      for (const uid of attr.components) {
+        addComponentImport(uid, imports, schema, relativePrefix);
+      }
+    }
+  }
+  if (imports.size === 0) return "";
+  const lines = [];
+  for (const [schemaVarName, importPath] of imports) {
+    lines.push(`import { ${schemaVarName} } from '${importPath}';`);
+  }
+  return lines.join("\n") + "\n";
+}
+function addComponentImport(uid, imports, schema, relativePrefix) {
+  const componentName = uid.split(".").pop() || "";
+  if (!componentName) return;
+  const exists = schema.components.some((c) => c.name === componentName);
+  if (!exists) return;
+  const schemaVarName = `${toCamelCase(componentName)}Schema`;
+  if (imports.has(schemaVarName)) return;
+  const fileName = toKebabCase(componentName);
+  imports.set(schemaVarName, `${relativePrefix}/${fileName}`);
+}
+function generateCollectionSchemas(collection, schema, strapiVersion = "v5", advancedRelations = false) {
+  const name = toCamelCase(collection.singularName);
+  const pascalName = toPascalCase(collection.singularName);
+  const componentSchemaNames = buildComponentSchemaNames(collection.attributes, schema);
+  const schemaImports = generateSchemaImports(collection.attributes, schema, "collection");
+  const schemaOptions = {
+    isUpdate: false,
+    strapiVersion,
+    useAdvancedRelations: advancedRelations,
+    componentSchemaNames
+  };
+  const createResult = generateZodObjectSchema(collection.attributes, schemaOptions);
+  const updateResult = generateZodObjectSchema(collection.attributes, { ...schemaOptions, isUpdate: true });
+  return `/**
+ * ${collection.displayName} Zod Schemas
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ *
+ * These schemas can be used for:
+ * - Form validation (React Hook Form, TanStack Form, Formik, etc.)
+ * - API request/response validation
+ * - Type inference
+ */
+
+import { z } from 'zod';
+${schemaImports}
+/**
+ * Schema for creating a new ${collection.displayName}
+ */
+export const ${name}CreateSchema = ${createResult.schema};
+
+/**
+ * Schema for updating a ${collection.displayName}
+ * All fields are optional for partial updates
+ */
+export const ${name}UpdateSchema = ${updateResult.schema};
 
-  async update(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
-    const response = await ${toCamelCase(single.singularName)}Single.update({ data });
-    return response.data;
-  },
+/**
+ * Inferred types from schemas
+ * Use these for type-safe form handling
+ */
+export type ${pascalName}CreateInput = z.infer<typeof ${name}CreateSchema>;
+export type ${pascalName}UpdateInput = z.infer<typeof ${name}UpdateSchema>;
+`;
+}
+function generateSingleSchemas(single, schema, strapiVersion = "v5", advancedRelations = false) {
+  const name = toCamelCase(single.singularName);
+  const pascalName = toPascalCase(single.singularName);
+  const componentSchemaNames = buildComponentSchemaNames(single.attributes, schema);
+  const schemaImports = generateSchemaImports(single.attributes, schema, "single");
+  const updateResult = generateZodObjectSchema(single.attributes, {
+    isUpdate: true,
+    strapiVersion,
+    useAdvancedRelations: advancedRelations,
+    componentSchemaNames
+  });
+  return `/**
+ * ${single.displayName} Zod Schemas (Single Type)
+ * ${single.description || ""}
+ * Generated by strapi2front
+ *
+ * These schemas can be used for:
+ * - Form validation (React Hook Form, TanStack Form, Formik, etc.)
+ * - API request/response validation
+ * - Type inference
+ */
 
-  async delete(): Promise<void> {
-    await ${toCamelCase(single.singularName)}Single.delete();
-  },
-};
+import { z } from 'zod';
+${schemaImports}
+/**
+ * Schema for updating ${single.displayName}
+ * All fields are optional for partial updates
+ */
+export const ${name}UpdateSchema = ${updateResult.schema};
+
+/**
+ * Inferred type from schema
+ */
+export type ${pascalName}UpdateInput = z.infer<typeof ${name}UpdateSchema>;
 `;
 }
-function generateCollectionActions2(collection, strapiVersion) {
+function generateCollectionActions2(collection, options) {
+  const { strapiVersion, useExternalSchemas, draftAndPublish = false } = options;
   const typeName = toPascalCase(collection.singularName);
   const serviceName = toCamelCase(collection.singularName) + "Service";
   const actionPrefix = toCamelCase(collection.singularName);
   const isV4 = strapiVersion === "v4";
   const idInputSchema = isV4 ? "z.number().int().positive()" : "z.string()";
   const idParamName = isV4 ? "id" : "documentId";
+  const statusSchema = "z.enum(['draft', 'published']).optional()";
+  const schemaImport = useExternalSchemas ? `import { ${actionPrefix}CreateSchema, ${actionPrefix}UpdateSchema } from './schemas';` : "";
+  const createSchema = useExternalSchemas ? `${actionPrefix}CreateSchema` : "z.record(z.unknown())";
+  const updateSchema = useExternalSchemas ? `${actionPrefix}UpdateSchema` : "z.record(z.unknown())";
   return `/**
  * ${collection.displayName} Astro Actions
  * ${collection.description || ""}
@@ -3108,6 +4061,7 @@ import { defineAction } from 'astro:actions';
 import { z } from 'astro:schema';
 import { ${serviceName} } from './service';
 import type { ${typeName} } from './types';
+${schemaImport}
 
 export const ${actionPrefix}Actions = {
   getMany: defineAction({
@@ -3137,10 +4091,11 @@ export const ${actionPrefix}Actions = {
 
   create: defineAction({
     input: z.object({
-      data: z.record(z.unknown()),
+      data: ${createSchema},${draftAndPublish ? `
+      status: ${statusSchema},` : ""}
     }),
     handler: async (input) => {
-      const data = await ${serviceName}.create(input.data as Partial<${typeName}>);
+      const data = await ${serviceName}.create(input.data as Partial<${typeName}>${draftAndPublish ? ", { status: input.status }" : ""});
       return { data };
     },
   }),
@@ -3148,10 +4103,11 @@ export const ${actionPrefix}Actions = {
   update: defineAction({
     input: z.object({
       ${idParamName}: ${idInputSchema},
-      data: z.record(z.unknown()),
+      data: ${updateSchema},${draftAndPublish ? `
+      status: ${statusSchema},` : ""}
     }),
     handler: async (input) => {
-      const data = await ${serviceName}.update(input.${idParamName}, input.data as Partial<${typeName}>);
+      const data = await ${serviceName}.update(input.${idParamName}, input.data as Partial<${typeName}>${draftAndPublish ? ", { status: input.status }" : ""});
       return { data };
     },
   }),
@@ -3314,6 +4270,15 @@ ${mediaType}
  * @property {string} url
  */
 
+/**
+ * File metadata for uploads
+ * @see https://docs.strapi.io/cms/api/client#upload
+ * @typedef {Object} StrapiFileInfo
+ * @property {string} [name]
+ * @property {string} [alternativeText]
+ * @property {string} [caption]
+ */
+
 /**
  * @typedef {Object} StrapiPagination
  * @property {number} page
@@ -3348,29 +4313,26 @@ ${useESM ? "export {};" : "module.exports = {};"}
 function generateClientJSDoc(strapiVersion, apiPrefix = "/api", useESM = false) {
   const isV4 = strapiVersion === "v4";
   const normalizedPrefix = apiPrefix.startsWith("/") ? apiPrefix : "/" + apiPrefix;
-  const importStatement = useESM ? `import Strapi from 'strapi-sdk-js';` : `const Strapi = require('strapi-sdk-js').default;`;
+  const importStatement = useESM ? `import { strapi as createStrapi } from '@strapi/client';` : `const { strapi: createStrapi } = require('@strapi/client');`;
   if (isV4) {
     return `// @ts-check
 /**
  * Strapi Client (v4)
  * Generated by strapi2front
+ *
+ * Note: @strapi/client officially supports Strapi v5+
+ * This v4 client uses a compatibility layer for the nested attributes structure
  */
 
 ${importStatement}
 
 // Initialize the Strapi client
-const strapiUrl = process.env.STRAPI_URL || 'http://localhost:1337';
-const strapiToken = process.env.STRAPI_TOKEN;
-const strapiApiPrefix = process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
-
-const strapi = new Strapi({
-  url: strapiUrl,
-  prefix: strapiApiPrefix,
-  axiosOptions: {
-    headers: strapiToken ? {
-      Authorization: \`Bearer \${strapiToken}\`,
-    } : {},
-  },
+const baseURL = (process.env.STRAPI_URL || 'http://localhost:1337') + '${normalizedPrefix}';
+const authToken = process.env.STRAPI_TOKEN;
+
+const strapiClient = createStrapi({
+  baseURL,
+  auth: authToken,
 });
 
 /** @type {import('./utils').StrapiPagination} */
@@ -3437,18 +4399,19 @@ function flattenRelations(data) {
 }
 
 /**
- * Helper to get typed collection
+ * Helper to get typed collection (v4 compatibility wrapper)
  * @template T
  * @param {string} pluralName
  */
 function collection(pluralName) {
+  const col = strapiClient.collection(pluralName);
   return {
     /**
      * @param {Record<string, unknown>} [params]
      * @returns {Promise<{ data: T[], meta: { pagination: import('./utils').StrapiPagination } }>}
      */
     async find(params) {
-      const response = await strapi.find(pluralName, params);
+      const response = await col.find(params);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T[]} */
@@ -3474,7 +4437,7 @@ function collection(pluralName) {
      * @returns {Promise<{ data: T }>}
      */
     async findOne(id, params) {
-      const response = await strapi.findOne(pluralName, String(id), params);
+      const response = await col.findOne(String(id), params);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3482,11 +4445,11 @@ function collection(pluralName) {
       return { data };
     },
     /**
-     * @param {{ data: Partial<T> }} data
+     * @param {Partial<T>} data
      * @returns {Promise<{ data: T }>}
      */
     async create(data) {
-      const response = await strapi.create(pluralName, data.data);
+      const response = await col.create(data);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3495,11 +4458,11 @@ function collection(pluralName) {
     },
     /**
      * @param {number|string} id
-     * @param {{ data: Partial<T> }} data
+     * @param {Partial<T>} data
      * @returns {Promise<{ data: T }>}
      */
     async update(id, data) {
-      const response = await strapi.update(pluralName, String(id), data.data);
+      const response = await col.update(String(id), data);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3511,24 +4474,25 @@ function collection(pluralName) {
      * @returns {Promise<void>}
      */
     async delete(id) {
-      await strapi.delete(pluralName, String(id));
+      await col.delete(String(id));
     },
   };
 }
 
 /**
- * Helper to get typed single type
+ * Helper to get typed single type (v4 compatibility wrapper)
  * @template T
  * @param {string} singularName
  */
 function single(singularName) {
+  const singleType = strapiClient.single(singularName);
   return {
     /**
      * @param {Record<string, unknown>} [params]
      * @returns {Promise<{ data: T }>}
      */
     async find(params) {
-      const response = await strapi.find(singularName, params);
+      const response = await singleType.find(params);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3536,11 +4500,11 @@ function single(singularName) {
       return { data };
     },
     /**
-     * @param {{ data: Partial<T> }} data
+     * @param {Partial<T>} data
      * @returns {Promise<{ data: T }>}
      */
     async update(data) {
-      const response = await strapi.update(singularName, String(1), data.data);
+      const response = await singleType.update(data);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3551,35 +4515,97 @@ function single(singularName) {
      * @returns {Promise<void>}
      */
     async delete() {
-      await strapi.delete(singularName, String(1));
+      await singleType.delete();
     },
   };
 }
 
-${useESM ? "export { strapi, collection, single };" : "module.exports = { strapi, collection, single };"}
+/**
+ * File management helpers
+ * Wraps @strapi/client file methods with proper typing
+ * @see https://docs.strapi.io/cms/api/client#working-with-files
+ */
+const files = {
+  /**
+   * Upload a file to Strapi
+   * @param {File|Blob} file
+   * @param {{ fileInfo?: import('./utils').StrapiFileInfo }} [options]
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   * @see https://docs.strapi.io/cms/api/client#upload
+   */
+  async upload(file, options) {
+    /** @type {any} */
+    const response = await strapiClient.files.upload(file, options);
+    return response;
+  },
+
+  /**
+   * Find files with optional filtering and sorting
+   * @param {Record<string, unknown>} [params]
+   * @returns {Promise<import('./utils').StrapiMedia[]>}
+   */
+  async find(params) {
+    /** @type {any} */
+    const response = await strapiClient.files.find(params);
+    return Array.isArray(response) ? response : [];
+  },
+
+  /**
+   * Get a single file by ID
+   * @param {number} fileId
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   */
+  async findOne(fileId) {
+    /** @type {any} */
+    const response = await strapiClient.files.findOne(fileId);
+    return response;
+  },
+
+  /**
+   * Update file metadata (name, alternativeText, caption)
+   * @param {number} fileId
+   * @param {import('./utils').StrapiFileInfo} fileInfo
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   */
+  async update(fileId, fileInfo) {
+    /** @type {any} */
+    const response = await strapiClient.files.update(fileId, fileInfo);
+    return response;
+  },
+
+  /**
+   * Delete a file by ID
+   * @param {number} fileId
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   */
+  async delete(fileId) {
+    /** @type {any} */
+    const response = await strapiClient.files.delete(fileId);
+    return response;
+  },
+};
+
+${useESM ? "export { strapiClient, collection, single, files };" : "module.exports = { strapiClient, collection, single, files };"}
 `;
   }
   return `// @ts-check
 /**
  * Strapi Client (v5)
  * Generated by strapi2front
+ *
+ * Using official @strapi/client
+ * @see https://docs.strapi.io/cms/api/client
  */
 
 ${importStatement}
 
 // Initialize the Strapi client
-const strapiUrl = process.env.STRAPI_URL || 'http://localhost:1337';
-const strapiToken = process.env.STRAPI_TOKEN;
-const strapiApiPrefix = process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
-
-const strapi = new Strapi({
-  url: strapiUrl,
-  prefix: strapiApiPrefix,
-  axiosOptions: {
-    headers: strapiToken ? {
-      Authorization: \`Bearer \${strapiToken}\`,
-    } : {},
-  },
+const baseURL = (process.env.STRAPI_URL || 'http://localhost:1337') + '${normalizedPrefix}';
+const authToken = process.env.STRAPI_TOKEN;
+
+const strapiClient = createStrapi({
+  baseURL,
+  auth: authToken,
 });
 
 /** @type {import('./utils').StrapiPagination} */
@@ -3596,13 +4622,14 @@ const defaultPagination = {
  * @param {string} pluralName
  */
 function collection(pluralName) {
+  const col = strapiClient.collection(pluralName);
   return {
     /**
      * @param {Record<string, unknown>} [params]
      * @returns {Promise<{ data: T[], meta: { pagination: import('./utils').StrapiPagination } }>}
      */
     async find(params) {
-      const response = await strapi.find(pluralName, params);
+      const response = await col.find(params);
       /** @type {any} */
       const rawMeta = response.meta;
       /** @type {any} */
@@ -3626,7 +4653,7 @@ function collection(pluralName) {
      * @returns {Promise<{ data: T }>}
      */
     async findOne(documentId, params) {
-      const response = await strapi.findOne(pluralName, documentId, params);
+      const response = await col.findOne(documentId, params);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3634,11 +4661,11 @@ function collection(pluralName) {
       return { data };
     },
     /**
-     * @param {{ data: Partial<T> }} data
+     * @param {Partial<T>} data
      * @returns {Promise<{ data: T }>}
      */
     async create(data) {
-      const response = await strapi.create(pluralName, data.data);
+      const response = await col.create(data);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3647,11 +4674,11 @@ function collection(pluralName) {
     },
     /**
      * @param {string} documentId
-     * @param {{ data: Partial<T> }} data
+     * @param {Partial<T>} data
      * @returns {Promise<{ data: T }>}
      */
     async update(documentId, data) {
-      const response = await strapi.update(pluralName, documentId, data.data);
+      const response = await col.update(documentId, data);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3663,7 +4690,7 @@ function collection(pluralName) {
      * @returns {Promise<void>}
      */
     async delete(documentId) {
-      await strapi.delete(pluralName, documentId);
+      await col.delete(documentId);
     },
   };
 }
@@ -3674,13 +4701,14 @@ function collection(pluralName) {
  * @param {string} singularName
  */
 function single(singularName) {
+  const singleType = strapiClient.single(singularName);
   return {
     /**
      * @param {Record<string, unknown>} [params]
      * @returns {Promise<{ data: T }>}
      */
     async find(params) {
-      const response = await strapi.find(singularName, params);
+      const response = await singleType.find(params);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3688,11 +4716,11 @@ function single(singularName) {
       return { data };
     },
     /**
-     * @param {{ data: Partial<T> }} data
+     * @param {Partial<T>} data
      * @returns {Promise<{ data: T }>}
      */
     async update(data) {
-      const response = await strapi.update(singularName, String(1), data.data);
+      const response = await singleType.update(data);
       /** @type {any} */
       const rawData = response.data;
       /** @type {T} */
@@ -3703,12 +4731,77 @@ function single(singularName) {
      * @returns {Promise<void>}
      */
     async delete() {
-      await strapi.delete(singularName, String(1));
+      await singleType.delete();
     },
   };
 }
 
-${useESM ? "export { strapi, collection, single };" : "module.exports = { strapi, collection, single };"}
+/**
+ * File management helpers
+ * Wraps @strapi/client file methods with proper typing
+ * @see https://docs.strapi.io/cms/api/client#working-with-files
+ */
+const files = {
+  /**
+   * Upload a file to Strapi
+   * @param {File|Blob} file
+   * @param {{ fileInfo?: import('./utils').StrapiFileInfo }} [options]
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   * @see https://docs.strapi.io/cms/api/client#upload
+   */
+  async upload(file, options) {
+    /** @type {any} */
+    const response = await strapiClient.files.upload(file, options);
+    return response;
+  },
+
+  /**
+   * Find files with optional filtering and sorting
+   * @param {Record<string, unknown>} [params]
+   * @returns {Promise<import('./utils').StrapiMedia[]>}
+   */
+  async find(params) {
+    /** @type {any} */
+    const response = await strapiClient.files.find(params);
+    return Array.isArray(response) ? response : [];
+  },
+
+  /**
+   * Get a single file by ID
+   * @param {number} fileId
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   */
+  async findOne(fileId) {
+    /** @type {any} */
+    const response = await strapiClient.files.findOne(fileId);
+    return response;
+  },
+
+  /**
+   * Update file metadata (name, alternativeText, caption)
+   * @param {number} fileId
+   * @param {import('./utils').StrapiFileInfo} fileInfo
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   */
+  async update(fileId, fileInfo) {
+    /** @type {any} */
+    const response = await strapiClient.files.update(fileId, fileInfo);
+    return response;
+  },
+
+  /**
+   * Delete a file by ID
+   * @param {number} fileId
+   * @returns {Promise<import('./utils').StrapiMedia>}
+   */
+  async delete(fileId) {
+    /** @type {any} */
+    const response = await strapiClient.files.delete(fileId);
+    return response;
+  },
+};
+
+${useESM ? "export { strapiClient, collection, single, files };" : "module.exports = { strapiClient, collection, single, files };"}
 `;
 }
 function generateLocalesFileJSDoc(locales, useESM = false) {
@@ -4086,7 +5179,7 @@ ${hasSlug ? `
    * @returns {Promise<import('./types').${typeName}>}
    */
   async create(data) {
-    const response = await ${toCamelCase(collection.singularName)}Collection.create({ data });
+    const response = await ${toCamelCase(collection.singularName)}Collection.create(data);
     return response.data;
   },
 
@@ -4096,7 +5189,7 @@ ${hasSlug ? `
    * @returns {Promise<import('./types').${typeName}>}
    */
   async update(${idParam}, data) {
-    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idParam}, { data });
+    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idParam}, data);
     return response.data;
   },
 
@@ -4174,7 +5267,7 @@ const ${serviceName} = {
    * @returns {Promise<import('./types').${typeName}>}
    */
   async update(data) {
-    const response = await ${toCamelCase(single.singularName)}Single.update({ data });
+    const response = await ${toCamelCase(single.singularName)}Single.update(data);
     return response.data;
   },
 
@@ -4189,6 +5282,259 @@ const ${serviceName} = {
 ${useESM ? `export { ${serviceName} };` : `module.exports = { ${serviceName} };`}
 `;
 }
+function generateUploadClientTS() {
+  return `/**
+ * Public Upload Client
+ * Generated by strapi2front
+ *
+ * Uploads files directly from the browser to Strapi using a restricted public token.
+ * This token should ONLY have upload permissions (no delete, no update).
+ *
+ * Required environment variables:
+ *   PUBLIC_STRAPI_URL - Your Strapi CMS base URL
+ *   PUBLIC_STRAPI_UPLOAD_TOKEN - Restricted API token (upload-only)
+ *
+ * Create the token in: Strapi Admin > Settings > API Tokens
+ * Set permissions: Upload > upload (only)
+ */
+
+import type { StrapiMedia, StrapiFileInfo } from './utils';
+
+const STRAPI_URL = import.meta.env.PUBLIC_STRAPI_URL || '';
+const UPLOAD_TOKEN = import.meta.env.PUBLIC_STRAPI_UPLOAD_TOKEN || '';
+
+/**
+ * Upload a single file to Strapi from the browser
+ */
+export async function uploadFile(
+  file: File,
+  fileInfo?: StrapiFileInfo
+): Promise<StrapiMedia> {
+  const formData = new FormData();
+  formData.append('files', file);
+
+  if (fileInfo) {
+    formData.append('fileInfo', JSON.stringify(fileInfo));
+  }
+
+  const response = await fetch(\`\${STRAPI_URL}/api/upload\`, {
+    method: 'POST',
+    headers: {
+      Authorization: \`Bearer \${UPLOAD_TOKEN}\`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    throw new Error(\`Upload failed: \${response.status} \${response.statusText}\`);
+  }
+
+  const data = await response.json();
+  return Array.isArray(data) ? data[0] : data;
+}
+
+/**
+ * Upload multiple files to Strapi from the browser
+ */
+export async function uploadFiles(
+  files: File[],
+  fileInfo?: StrapiFileInfo
+): Promise<StrapiMedia[]> {
+  const formData = new FormData();
+  files.forEach((f) => formData.append('files', f));
+
+  if (fileInfo) {
+    formData.append('fileInfo', JSON.stringify(fileInfo));
+  }
+
+  const response = await fetch(\`\${STRAPI_URL}/api/upload\`, {
+    method: 'POST',
+    headers: {
+      Authorization: \`Bearer \${UPLOAD_TOKEN}\`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    throw new Error(\`Upload failed: \${response.status} \${response.statusText}\`);
+  }
+
+  return response.json();
+}
+`;
+}
+function generateUploadClientJSDoc(useESM) {
+  return `/**
+ * Public Upload Client
+ * Generated by strapi2front
+ *
+ * Uploads files directly from the browser to Strapi using a restricted public token.
+ * This token should ONLY have upload permissions (no delete, no update).
+ *
+ * Required environment variables:
+ *   PUBLIC_STRAPI_URL - Your Strapi CMS base URL
+ *   PUBLIC_STRAPI_UPLOAD_TOKEN - Restricted API token (upload-only)
+ *
+ * Create the token in: Strapi Admin > Settings > API Tokens
+ * Set permissions: Upload > upload (only)
+ */
+
+/** @typedef {import('./utils').StrapiMedia} StrapiMedia */
+/** @typedef {import('./utils').StrapiFileInfo} StrapiFileInfo */
+
+const STRAPI_URL = ${useESM ? "import.meta.env.PUBLIC_STRAPI_URL || ''" : "process.env.PUBLIC_STRAPI_URL || ''"};
+const UPLOAD_TOKEN = ${useESM ? "import.meta.env.PUBLIC_STRAPI_UPLOAD_TOKEN || ''" : "process.env.PUBLIC_STRAPI_UPLOAD_TOKEN || ''"};
+
+/**
+ * Upload a single file to Strapi from the browser
+ * @param {File} file - The file to upload
+ * @param {StrapiFileInfo} [fileInfo] - Optional file metadata
+ * @returns {Promise<StrapiMedia>}
+ */
+${useESM ? "export " : ""}async function uploadFile(file, fileInfo) {
+  const formData = new FormData();
+  formData.append('files', file);
+
+  if (fileInfo) {
+    formData.append('fileInfo', JSON.stringify(fileInfo));
+  }
+
+  const response = await fetch(\`\${STRAPI_URL}/api/upload\`, {
+    method: 'POST',
+    headers: {
+      Authorization: \`Bearer \${UPLOAD_TOKEN}\`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    throw new Error(\`Upload failed: \${response.status} \${response.statusText}\`);
+  }
+
+  const data = await response.json();
+  return Array.isArray(data) ? data[0] : data;
+}
+
+/**
+ * Upload multiple files to Strapi from the browser
+ * @param {File[]} files - The files to upload
+ * @param {StrapiFileInfo} [fileInfo] - Optional file metadata (applied to all)
+ * @returns {Promise<StrapiMedia[]>}
+ */
+${useESM ? "export " : ""}async function uploadFiles(files, fileInfo) {
+  const formData = new FormData();
+  files.forEach((f) => formData.append('files', f));
+
+  if (fileInfo) {
+    formData.append('fileInfo', JSON.stringify(fileInfo));
+  }
+
+  const response = await fetch(\`\${STRAPI_URL}/api/upload\`, {
+    method: 'POST',
+    headers: {
+      Authorization: \`Bearer \${UPLOAD_TOKEN}\`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    throw new Error(\`Upload failed: \${response.status} \${response.statusText}\`);
+  }
+
+  return response.json();
+}
+
+${useESM ? "" : "module.exports = { uploadFile, uploadFiles };"}
+`;
+}
+function generateUploadActionTS() {
+  return `/**
+ * Upload Action
+ * Generated by strapi2front
+ *
+ * Astro Action that receives files via FormData and uploads them to Strapi server-side.
+ * Uses the private STRAPI_TOKEN \u2014 never exposed to the browser.
+ *
+ * Usage:
+ *   import { actions } from 'astro:actions';
+ *   const result = await actions.upload({ file: myFile, alternativeText: 'My image' });
+ *
+ * Register this action in src/actions/index.ts:
+ *   import { uploadAction, uploadMultipleAction } from '../strapi/shared/upload-action';
+ *   export const server = { upload: uploadAction, uploadMultiple: uploadMultipleAction };
+ */
+
+import { defineAction, ActionError } from 'astro:actions';
+import { z } from 'astro:schema';
+import { files } from './client';
+
+/**
+ * Upload a single file via Astro Action (server-side, secure)
+ */
+export const uploadAction = defineAction({
+  accept: 'form',
+  input: z.object({
+    file: z.instanceof(File),
+    name: z.string().optional(),
+    alternativeText: z.string().optional(),
+    caption: z.string().optional(),
+  }),
+  handler: async (input) => {
+    try {
+      const { file, name, alternativeText, caption } = input;
+
+      const fileInfo: Record<string, string> = {};
+      if (name) fileInfo.name = name;
+      if (alternativeText) fileInfo.alternativeText = alternativeText;
+      if (caption) fileInfo.caption = caption;
+
+      const result = await files.upload(file, {
+        fileInfo: Object.keys(fileInfo).length > 0 ? fileInfo : undefined,
+      });
+
+      return result;
+    } catch (error) {
+      throw new ActionError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: error instanceof Error ? error.message : 'Upload failed',
+      });
+    }
+  },
+});
+
+/**
+ * Upload multiple files via Astro Action (server-side, secure)
+ */
+export const uploadMultipleAction = defineAction({
+  accept: 'form',
+  input: z.object({
+    files: z.array(z.instanceof(File)).min(1),
+    alternativeText: z.string().optional(),
+    caption: z.string().optional(),
+  }),
+  handler: async (input) => {
+    try {
+      const results = await Promise.all(
+        input.files.map((file) =>
+          files.upload(file, {
+            fileInfo: {
+              ...(input.alternativeText && { alternativeText: input.alternativeText }),
+              ...(input.caption && { caption: input.caption }),
+            },
+          })
+        )
+      );
+      return results;
+    } catch (error) {
+      throw new ActionError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: error instanceof Error ? error.message : 'Upload failed',
+      });
+    }
+  },
+});
+`;
+}
 
 // src/frameworks/nextjs/actions.ts
 async function generateNextJsActions(_schema, _options) {
@@ -4222,7 +5568,176 @@ var frameworkSupport = {
   nextjs: { status: "coming-soon", minVersion: "14.0.0" },
   nuxt: { status: "coming-soon", minVersion: "3.0.0" }
 };
+async function generateZodSchemas(schema, options) {
+  const { outputDir, byFeature = false, strapiVersion = "v5" } = options;
+  const generatedFiles = [];
+  await ensureDir(outputDir);
+  if (byFeature) {
+    for (const collection of schema.collections) {
+      const dirPath = path9.join(outputDir, "collections", toKebabCase(collection.singularName));
+      await ensureDir(dirPath);
+      const filePath = path9.join(dirPath, "schemas.ts");
+      const content = generateCollectionSchemas2(collection, schema.components, strapiVersion);
+      await writeFile(filePath, await formatCode(content));
+      generatedFiles.push({
+        filePath,
+        schemas: [
+          `${toCamelCase(collection.singularName)}CreateSchema`,
+          `${toCamelCase(collection.singularName)}UpdateSchema`
+        ]
+      });
+    }
+    for (const single of schema.singles) {
+      const dirPath = path9.join(outputDir, "singles", toKebabCase(single.singularName));
+      await ensureDir(dirPath);
+      const filePath = path9.join(dirPath, "schemas.ts");
+      const content = generateSingleSchemas2(single, schema.components, strapiVersion);
+      await writeFile(filePath, await formatCode(content));
+      generatedFiles.push({
+        filePath,
+        schemas: [`${toCamelCase(single.singularName)}UpdateSchema`]
+      });
+    }
+  } else {
+    const filePath = path9.join(outputDir, "schemas.ts");
+    const content = generateAllSchemas(schema, strapiVersion);
+    await writeFile(filePath, await formatCode(content));
+    const allSchemas = [];
+    for (const collection of schema.collections) {
+      allSchemas.push(`${toCamelCase(collection.singularName)}CreateSchema`);
+      allSchemas.push(`${toCamelCase(collection.singularName)}UpdateSchema`);
+    }
+    for (const single of schema.singles) {
+      allSchemas.push(`${toCamelCase(single.singularName)}UpdateSchema`);
+    }
+    generatedFiles.push({ filePath, schemas: allSchemas });
+  }
+  return generatedFiles;
+}
+function generateAllSchemas(schema, strapiVersion = "v5") {
+  const sections = [];
+  sections.push(`/**
+ * Zod Validation Schemas
+ * Generated by strapi2front
+ *
+ * These schemas can be used for form validation, API input validation, etc.
+ */
+
+import { z } from 'zod';
+`);
+  if (schema.collections.length > 0) {
+    sections.push("// ============================================");
+    sections.push("// Collection Schemas");
+    sections.push("// ============================================\n");
+    for (const collection of schema.collections) {
+      sections.push(generateCollectionSchemaContent(collection, schema.components, strapiVersion));
+      sections.push("");
+    }
+  }
+  if (schema.singles.length > 0) {
+    sections.push("// ============================================");
+    sections.push("// Single Type Schemas");
+    sections.push("// ============================================\n");
+    for (const single of schema.singles) {
+      sections.push(generateSingleSchemaContent(single, schema.components, strapiVersion));
+      sections.push("");
+    }
+  }
+  sections.push("// ============================================");
+  sections.push("// Schema Exports");
+  sections.push("// ============================================\n");
+  const exports$1 = [];
+  for (const collection of schema.collections) {
+    const name = toCamelCase(collection.singularName);
+    exports$1.push(`  ${name}CreateSchema,`);
+    exports$1.push(`  ${name}UpdateSchema,`);
+  }
+  for (const single of schema.singles) {
+    const name = toCamelCase(single.singularName);
+    exports$1.push(`  ${name}UpdateSchema,`);
+  }
+  sections.push(`export const schemas = {
+${exports$1.join("\n")}
+};`);
+  return sections.join("\n");
+}
+function generateCollectionSchemas2(collection, _components, strapiVersion = "v5") {
+  const name = toCamelCase(collection.singularName);
+  const pascalName = toPascalCase(collection.singularName);
+  return `/**
+ * ${collection.displayName} Zod Schemas
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ */
+
+import { z } from 'zod';
+
+${generateCollectionSchemaContent(collection, _components, strapiVersion)}
+
+// Type inference helpers
+export type ${pascalName}CreateInput = z.infer<typeof ${name}CreateSchema>;
+export type ${pascalName}UpdateInput = z.infer<typeof ${name}UpdateSchema>;
+`;
+}
+function generateSingleSchemas2(single, _components, strapiVersion = "v5") {
+  const name = toCamelCase(single.singularName);
+  const pascalName = toPascalCase(single.singularName);
+  return `/**
+ * ${single.displayName} Zod Schemas
+ * ${single.description || ""}
+ * Generated by strapi2front
+ */
+
+import { z } from 'zod';
+
+${generateSingleSchemaContent(single, _components, strapiVersion)}
+
+// Type inference helpers
+export type ${pascalName}UpdateInput = z.infer<typeof ${name}UpdateSchema>;
+`;
+}
+function generateCollectionSchemaContent(collection, _components, strapiVersion = "v5") {
+  const name = toCamelCase(collection.singularName);
+  const sections = [];
+  const createOptions = {
+    isUpdate: false,
+    strapiVersion
+  };
+  const updateOptions = {
+    isUpdate: true,
+    strapiVersion
+  };
+  const createResult = generateZodObjectSchema(collection.attributes, createOptions);
+  sections.push(`/**
+ * Schema for creating a new ${collection.displayName}
+ */
+export const ${name}CreateSchema = ${createResult.schema};`);
+  if (createResult.skippedFields.length > 0) {
+    sections.push(`// Skipped fields: ${createResult.skippedFields.map((f) => f.name).join(", ")}`);
+  }
+  sections.push("");
+  const updateResult = generateZodObjectSchema(collection.attributes, updateOptions);
+  sections.push(`/**
+ * Schema for updating a ${collection.displayName}
+ * All fields are optional for partial updates
+ */
+export const ${name}UpdateSchema = ${updateResult.schema};`);
+  return sections.join("\n");
+}
+function generateSingleSchemaContent(single, _components, strapiVersion = "v5") {
+  const name = toCamelCase(single.singularName);
+  const updateOptions = {
+    isUpdate: true,
+    strapiVersion
+  };
+  const updateResult = generateZodObjectSchema(single.attributes, updateOptions);
+  return `/**
+ * Schema for updating ${single.displayName}
+ * All fields are optional for partial updates
+ */
+export const ${name}UpdateSchema = ${updateResult.schema};`;
+}
 
-export { deleteFile, ensureDir, fileExists, formatCode, formatJson, frameworkSupport, generateActions, generateAstroActions, generateByFeature, generateClient, generateJSDocServices, generateJSDocTypes, generateLocales, generateNextJsActions, generateNuxtServerRoutes, generateServices, generateTypeScriptTypes, generateTypes, isAstroActionsSupported, isNextJsActionsSupported, isNuxtServerRoutesSupported, listFiles, pluralize, readFile, toCamelCase, toKebabCase, toPascalCase, writeFile };
+export { deleteFile, ensureDir, fileExists, formatCode, formatJson, frameworkSupport, generateActions, generateAstroActions, generateByFeature, generateClient, generateJSDocServices, generateJSDocTypes, generateLocales, generateNextJsActions, generateNuxtServerRoutes, generateServices, generateTypeScriptTypes, generateTypes, generateZodObjectSchema, generateZodSchemas, isAstroActionsSupported, isNextJsActionsSupported, isNuxtServerRoutesSupported, isSystemField, listFiles, mapAttributeToZodSchema, pluralize, readFile, toCamelCase, toKebabCase, toPascalCase, writeFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map