@strapi2front/generators 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,8 +1,8 @@
-import path7 from 'path';
+import path9 from 'path';
 import * as prettier from 'prettier';
 import fs from 'fs/promises';
 
-// src/types/generator.ts
+// src/output/typescript/types.ts
 async function formatCode(code) {
   try {
     return await prettier.format(code, {
@@ -38,7 +38,7 @@ async function ensureDir(dirPath) {
   }
 }
 async function writeFile(filePath, content) {
-  const dir = path7.dirname(filePath);
+  const dir = path9.dirname(filePath);
   await ensureDir(dir);
   await fs.writeFile(filePath, content, "utf-8");
 }
@@ -65,7 +65,7 @@ async function deleteFile(filePath) {
 async function listFiles(dirPath, extension) {
   try {
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    let files = entries.filter((entry) => entry.isFile()).map((entry) => path7.join(dirPath, entry.name));
+    let files = entries.filter((entry) => entry.isFile()).map((entry) => path9.join(dirPath, entry.name));
     if (extension) {
       files = files.filter((file) => file.endsWith(extension));
     }
@@ -96,33 +96,179 @@ function pluralize(word) {
   return word + "s";
 }
 
-// src/types/generator.ts
-async function generateTypes(schema, options) {
+// src/shared/type-mapper.ts
+function mapAttributeToType(attr, _components) {
+  switch (attr.type) {
+    case "string":
+    case "text":
+    case "richtext":
+    case "email":
+    case "password":
+    case "uid":
+      return { type: "string", needsImport: false };
+    case "blocks":
+      return {
+        type: "BlocksContent",
+        needsImport: true,
+        import: { name: "BlocksContent", from: "utils" }
+      };
+    case "integer":
+    case "biginteger":
+    case "float":
+    case "decimal":
+      return { type: "number", needsImport: false };
+    case "boolean":
+      return { type: "boolean", needsImport: false };
+    case "date":
+    case "time":
+    case "datetime":
+    case "timestamp":
+      return { type: "string", needsImport: false };
+    case "json":
+      return { type: "unknown", needsImport: false };
+    case "enumeration":
+      if ("enum" in attr && attr.enum) {
+        return {
+          type: attr.enum.map((v) => `'${v}'`).join(" | "),
+          needsImport: false
+        };
+      }
+      return { type: "string", needsImport: false };
+    case "media":
+      if ("multiple" in attr && attr.multiple) {
+        return {
+          type: "StrapiMedia[]",
+          needsImport: true,
+          import: { name: "StrapiMedia", from: "utils" }
+        };
+      }
+      return {
+        type: "StrapiMedia | null",
+        needsImport: true,
+        import: { name: "StrapiMedia", from: "utils" }
+      };
+    case "relation":
+      if ("target" in attr && attr.target) {
+        const targetName = attr.target.split(".").pop() || "unknown";
+        const typeName = toPascalCase(targetName);
+        const isMany = attr.relation === "oneToMany" || attr.relation === "manyToMany";
+        return {
+          type: isMany ? `${typeName}[]` : `${typeName} | null`,
+          needsImport: true,
+          import: { name: typeName, from: targetName, isRelation: true }
+        };
+      }
+      return { type: "unknown", needsImport: false };
+    case "component":
+      if ("component" in attr && attr.component) {
+        const componentName = attr.component.split(".").pop() || "unknown";
+        const typeName = toPascalCase(componentName);
+        if ("repeatable" in attr && attr.repeatable) {
+          return {
+            type: `${typeName}[]`,
+            needsImport: true,
+            import: { name: typeName, from: componentName, isComponent: true }
+          };
+        }
+        return {
+          type: `${typeName} | null`,
+          needsImport: true,
+          import: { name: typeName, from: componentName, isComponent: true }
+        };
+      }
+      return { type: "unknown", needsImport: false };
+    case "dynamiczone":
+      if ("components" in attr && attr.components) {
+        const types = attr.components.map((c) => {
+          const name = c.split(".").pop() || "unknown";
+          return toPascalCase(name);
+        });
+        return {
+          type: `(${types.join(" | ")})[]`,
+          needsImport: true
+          // Dynamic zones need multiple imports, handled separately
+        };
+      }
+      return { type: "unknown[]", needsImport: false };
+    default:
+      return { type: "unknown", needsImport: false };
+  }
+}
+function getAttributeComment(attr) {
+  const parts = [];
+  if (attr.required) {
+    parts.push("Required");
+  }
+  if ("minLength" in attr && attr.minLength !== void 0) {
+    parts.push(`Min length: ${attr.minLength}`);
+  }
+  if ("maxLength" in attr && attr.maxLength !== void 0) {
+    parts.push(`Max length: ${attr.maxLength}`);
+  }
+  if ("min" in attr && attr.min !== void 0) {
+    parts.push(`Min: ${attr.min}`);
+  }
+  if ("max" in attr && attr.max !== void 0) {
+    parts.push(`Max: ${attr.max}`);
+  }
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function extractDependencies(attributes, selfName) {
+  const relations = /* @__PURE__ */ new Set();
+  const components = /* @__PURE__ */ new Set();
+  for (const attr of Object.values(attributes)) {
+    if (attr.type === "relation" && "target" in attr && attr.target) {
+      const targetName = attr.target.split(".").pop() || "";
+      const typeName = toPascalCase(targetName);
+      if (typeName !== selfName && targetName) {
+        relations.add(targetName);
+      }
+    }
+    if (attr.type === "component" && "component" in attr && attr.component) {
+      const componentName = attr.component.split(".").pop() || "";
+      if (componentName) {
+        components.add(componentName);
+      }
+    }
+    if (attr.type === "dynamiczone" && "components" in attr && attr.components) {
+      for (const comp of attr.components) {
+        const componentName = comp.split(".").pop() || "";
+        if (componentName) {
+          components.add(componentName);
+        }
+      }
+    }
+  }
+  return { relations, components };
+}
+
+// src/output/typescript/types.ts
+async function generateTypeScriptTypes(schema, options) {
   const { outputDir } = options;
   const generatedFiles = [];
-  await ensureDir(path7.join(outputDir, "collections"));
-  await ensureDir(path7.join(outputDir, "components"));
-  const utilsPath = path7.join(outputDir, "utils.ts");
+  await ensureDir(path9.join(outputDir, "collections"));
+  await ensureDir(path9.join(outputDir, "components"));
+  const utilsPath = path9.join(outputDir, "utils.ts");
   const strapiVersion = options.strapiVersion ?? "v5";
   await writeFile(utilsPath, await formatCode(generateUtilityTypes(options.blocksRendererInstalled ?? false, strapiVersion)));
   generatedFiles.push(utilsPath);
   for (const collection of schema.collections) {
     const fileName = `${toKebabCase(collection.singularName)}.ts`;
-    const filePath = path7.join(outputDir, "collections", fileName);
+    const filePath = path9.join(outputDir, "collections", fileName);
     const content = generateCollectionType(collection, schema.components);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
   }
   for (const single of schema.singles) {
     const fileName = `${toKebabCase(single.singularName)}.ts`;
-    const filePath = path7.join(outputDir, "collections", fileName);
+    const filePath = path9.join(outputDir, "collections", fileName);
     const content = generateSingleType(single, schema.components);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
   }
   for (const component of schema.components) {
     const fileName = `${toKebabCase(component.name)}.ts`;
-    const filePath = path7.join(outputDir, "components", fileName);
+    const filePath = path9.join(outputDir, "components", fileName);
     const content = generateComponentType(component);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
@@ -306,34 +452,6 @@ ${rawResponseTypes}
 ${blocksContentType}
 `;
 }
-function extractDependencies(attributes, selfName) {
-  const relations = /* @__PURE__ */ new Set();
-  const components = /* @__PURE__ */ new Set();
-  for (const attr of Object.values(attributes)) {
-    if (attr.type === "relation" && "target" in attr && attr.target) {
-      const targetName = attr.target.split(".").pop() || "";
-      const typeName = toPascalCase(targetName);
-      if (typeName !== selfName && targetName) {
-        relations.add(targetName);
-      }
-    }
-    if (attr.type === "component" && "component" in attr && attr.component) {
-      const componentName = attr.component.split(".").pop() || "";
-      if (componentName) {
-        components.add(componentName);
-      }
-    }
-    if (attr.type === "dynamiczone" && "components" in attr && attr.components) {
-      for (const comp of attr.components) {
-        const componentName = comp.split(".").pop() || "";
-        if (componentName) {
-          components.add(componentName);
-        }
-      }
-    }
-  }
-  return { relations, components };
-}
 function generateDependencyImports(relations, components) {
   const imports = [];
   for (const relation of relations) {
@@ -461,195 +579,369 @@ ${attributes}
 function generateAttributes(attributes, components) {
   const lines = [];
   for (const [name, attr] of Object.entries(attributes)) {
-    const tsType = attributeToTsType(attr);
+    const mappedType = mapAttributeToType(attr);
     const optional = attr.required ? "" : "?";
     const comment = getAttributeComment(attr);
     if (comment) {
       lines.push(`  /** ${comment} */`);
     }
-    lines.push(`  ${name}${optional}: ${tsType};`);
+    lines.push(`  ${name}${optional}: ${mappedType.type};`);
   }
   return lines.join("\n");
 }
-function attributeToTsType(attr, _components) {
-  switch (attr.type) {
-    case "string":
-    case "text":
-    case "richtext":
-    case "email":
-    case "password":
-    case "uid":
-      return "string";
-    case "blocks":
-      return "BlocksContent";
-    case "integer":
-    case "biginteger":
-    case "float":
-    case "decimal":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "date":
-    case "time":
-    case "datetime":
-    case "timestamp":
-      return "string";
-    case "json":
-      return "unknown";
-    case "enumeration":
-      if ("enum" in attr && attr.enum) {
-        return attr.enum.map((v) => `'${v}'`).join(" | ");
-      }
-      return "string";
-    case "media":
-      if ("multiple" in attr && attr.multiple) {
-        return "StrapiMedia[]";
-      }
-      return "StrapiMedia | null";
-    case "relation":
-      if ("target" in attr && attr.target) {
-        const targetName = toPascalCase(attr.target.split(".").pop() || "unknown");
-        const isMany = attr.relation === "oneToMany" || attr.relation === "manyToMany";
-        return isMany ? `${targetName}[]` : `${targetName} | null`;
-      }
-      return "unknown";
-    case "component":
-      if ("component" in attr && attr.component) {
-        const componentName = toPascalCase(attr.component.split(".").pop() || "unknown");
-        if ("repeatable" in attr && attr.repeatable) {
-          return `${componentName}[]`;
-        }
-        return `${componentName} | null`;
-      }
-      return "unknown";
-    case "dynamiczone":
-      if ("components" in attr && attr.components) {
-        const types = attr.components.map((c) => toPascalCase(c.split(".").pop() || "unknown"));
-        return `(${types.join(" | ")})[]`;
-      }
-      return "unknown[]";
-    default:
-      return "unknown";
-  }
-}
-function getAttributeComment(attr) {
-  const parts = [];
-  if (attr.required) {
-    parts.push("Required");
-  }
-  if ("minLength" in attr && attr.minLength !== void 0) {
-    parts.push(`Min length: ${attr.minLength}`);
-  }
-  if ("maxLength" in attr && attr.maxLength !== void 0) {
-    parts.push(`Max length: ${attr.maxLength}`);
-  }
-  if ("min" in attr && attr.min !== void 0) {
-    parts.push(`Min: ${attr.min}`);
-  }
-  if ("max" in attr && attr.max !== void 0) {
-    parts.push(`Max: ${attr.max}`);
-  }
-  return parts.length > 0 ? parts.join(", ") : null;
-}
-async function generateServices(schema, options) {
-  const { outputDir, typesImportPath, strapiVersion = "v5" } = options;
+async function generateJSDocTypes(schema, options) {
+  const { outputDir } = options;
   const generatedFiles = [];
-  await ensureDir(outputDir);
+  await ensureDir(path9.join(outputDir, "collections"));
+  await ensureDir(path9.join(outputDir, "components"));
+  const utilsPath = path9.join(outputDir, "utils.js");
+  const strapiVersion = options.strapiVersion ?? "v5";
+  await writeFile(utilsPath, generateUtilityTypes2(strapiVersion));
+  generatedFiles.push(utilsPath);
   for (const collection of schema.collections) {
-    const fileName = `${toKebabCase(collection.singularName)}.service.ts`;
-    const filePath = path7.join(outputDir, fileName);
-    const content = generateCollectionService(collection, typesImportPath, strapiVersion);
-    await writeFile(filePath, await formatCode(content));
+    const fileName = `${toKebabCase(collection.singularName)}.js`;
+    const filePath = path9.join(outputDir, "collections", fileName);
+    const content = generateCollectionType2(collection, schema.components, strapiVersion);
+    await writeFile(filePath, content);
     generatedFiles.push(filePath);
   }
   for (const single of schema.singles) {
-    const fileName = `${toKebabCase(single.singularName)}.service.ts`;
-    const filePath = path7.join(outputDir, fileName);
-    const content = generateSingleService(single, typesImportPath, strapiVersion);
-    await writeFile(filePath, await formatCode(content));
+    const fileName = `${toKebabCase(single.singularName)}.js`;
+    const filePath = path9.join(outputDir, "collections", fileName);
+    const content = generateSingleType2(single, schema.components, strapiVersion);
+    await writeFile(filePath, content);
+    generatedFiles.push(filePath);
+  }
+  for (const component of schema.components) {
+    const fileName = `${toKebabCase(component.name)}.js`;
+    const filePath = path9.join(outputDir, "components", fileName);
+    const content = generateComponentType2(component, strapiVersion);
+    await writeFile(filePath, content);
     generatedFiles.push(filePath);
   }
   return generatedFiles;
 }
-function generateCollectionService(collection, typesImportPath, strapiVersion) {
-  const typeName = toPascalCase(collection.singularName);
-  const serviceName = toCamelCase(collection.singularName) + "Service";
-  const fileName = toKebabCase(collection.singularName);
-  const endpoint = collection.pluralName;
+function generateUtilityTypes2(strapiVersion) {
   const isV4 = strapiVersion === "v4";
-  const idParam = isV4 ? "id: number" : "documentId: string";
-  const idName = isV4 ? "id" : "documentId";
-  const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt' | 'publishedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt' | 'publishedAt'";
-  const hasSlug = "slug" in collection.attributes;
-  const { localized, draftAndPublish } = collection;
-  const imports = [
-    `import { collection } from '../client';`,
-    `import type { ${typeName}, ${typeName}Filters } from '${typesImportPath}/collections/${fileName}';`,
-    `import type { StrapiPagination } from '${typesImportPath}/utils';`
-  ];
-  if (localized) {
-    imports.push(`import type { Locale } from '../locales';`);
-  }
-  const findManyOptionsFields = [
-    `  filters?: ${typeName}Filters;`,
-    `  pagination?: {`,
-    `    /** Page number (1-indexed) - use with pageSize */`,
-    `    page?: number;`,
-    `    /** Number of items per page (default: 25) - use with page */`,
-    `    pageSize?: number;`,
-    `    /** Offset to start from (0-indexed) - use with limit */`,
-    `    start?: number;`,
-    `    /** Maximum number of items to return - use with start */`,
-    `    limit?: number;`,
-    `  };`,
-    `  sort?: string | string[];`,
-    `  populate?: string | string[] | Record<string, unknown>;`
-  ];
-  if (localized) {
-    findManyOptionsFields.push(`  locale?: Locale;`);
-  }
-  if (draftAndPublish) {
-    findManyOptionsFields.push(`  status?: 'draft' | 'published';`);
+  const baseEntityFields = isV4 ? ` * @property {number} id
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ * @property {string|null} publishedAt` : ` * @property {number} id
+ * @property {string} documentId
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ * @property {string|null} publishedAt`;
+  const mediaFields = isV4 ? ` * @property {number} id` : ` * @property {number} id
+ * @property {string} documentId`;
+  return `/**
+ * Strapi utility types (JSDoc)
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ *
+ * These types provide IntelliSense support in JavaScript projects.
+ */
+
+/**
+ * Strapi media format
+ * @typedef {Object} StrapiMediaFormat
+ * @property {string} name
+ * @property {string} hash
+ * @property {string} ext
+ * @property {string} mime
+ * @property {number} width
+ * @property {number} height
+ * @property {number} size
+ * @property {string} url
+ */
+
+/**
+ * Strapi media object
+ * @typedef {Object} StrapiMedia
+${mediaFields}
+ * @property {string} name
+ * @property {string|null} alternativeText
+ * @property {string|null} caption
+ * @property {number} width
+ * @property {number} height
+ * @property {{thumbnail?: StrapiMediaFormat, small?: StrapiMediaFormat, medium?: StrapiMediaFormat, large?: StrapiMediaFormat}|null} formats
+ * @property {string} hash
+ * @property {string} ext
+ * @property {string} mime
+ * @property {number} size
+ * @property {string} url
+ * @property {string|null} previewUrl
+ * @property {string} provider
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ */
+
+/**
+ * Strapi pagination
+ * @typedef {Object} StrapiPagination
+ * @property {number} page
+ * @property {number} pageSize
+ * @property {number} pageCount
+ * @property {number} total
+ */
+
+/**
+ * Strapi response wrapper
+ * @template T
+ * @typedef {Object} StrapiResponse
+ * @property {T} data
+ * @property {{pagination?: StrapiPagination}} meta
+ */
+
+/**
+ * Strapi list response
+ * @template T
+ * @typedef {Object} StrapiListResponse
+ * @property {T[]} data
+ * @property {{pagination: StrapiPagination}} meta
+ */
+
+/**
+ * Base entity fields
+ * @typedef {Object} StrapiBaseEntity
+${baseEntityFields}
+ */
+
+/**
+ * Blocks content type (rich text)
+ * @typedef {unknown[]} BlocksContent
+ */
+
+// Export empty object to make this a module
+export {};
+`;
+}
+function generateCollectionType2(collection, components, strapiVersion) {
+  const typeName = toPascalCase(collection.singularName);
+  const isV4 = strapiVersion === "v4";
+  const { relations, components: componentDeps } = extractDependencies(collection.attributes, typeName);
+  const imports = generateJSDocImports(relations, componentDeps, "collection");
+  const properties = generateJSDocProperties(collection.attributes);
+  const baseFields = isV4 ? ` * @property {number} id
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ * @property {string|null} publishedAt` : ` * @property {number} id
+ * @property {string} documentId
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ * @property {string|null} publishedAt`;
+  return `/**
+ * ${collection.displayName}
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports}
+
+/**
+ * ${collection.displayName}
+ * @typedef {Object} ${typeName}
+${baseFields}
+${properties}
+ */
+
+/**
+ * ${typeName} filters for querying
+ * @typedef {Object} ${typeName}Filters
+ * @property {number|{$eq?: number, $ne?: number, $in?: number[], $notIn?: number[]}} [id]
+ * @property {string|{$eq?: string, $ne?: string}} [documentId]
+ * @property {string|{$eq?: string, $gt?: string, $gte?: string, $lt?: string, $lte?: string}} [createdAt]
+ * @property {string|{$eq?: string, $gt?: string, $gte?: string, $lt?: string, $lte?: string}} [updatedAt]
+ * @property {string|null|{$eq?: string, $ne?: string, $null?: boolean}} [publishedAt]
+ * @property {${typeName}Filters[]} [$and]
+ * @property {${typeName}Filters[]} [$or]
+ * @property {${typeName}Filters} [$not]
+ */
+
+// Export empty object to make this a module
+export {};
+`;
+}
+function generateSingleType2(single, components, strapiVersion) {
+  const typeName = toPascalCase(single.singularName);
+  const isV4 = strapiVersion === "v4";
+  const { relations, components: componentDeps } = extractDependencies(single.attributes, typeName);
+  const imports = generateJSDocImports(relations, componentDeps, "collection");
+  const properties = generateJSDocProperties(single.attributes);
+  const baseFields = isV4 ? ` * @property {number} id
+ * @property {string} createdAt
+ * @property {string} updatedAt` : ` * @property {number} id
+ * @property {string} documentId
+ * @property {string} createdAt
+ * @property {string} updatedAt`;
+  return `/**
+ * ${single.displayName}
+ * ${single.description || ""}
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports}
+
+/**
+ * ${single.displayName}
+ * @typedef {Object} ${typeName}
+${baseFields}
+${properties}
+ */
+
+// Export empty object to make this a module
+export {};
+`;
+}
+function generateComponentType2(component, strapiVersion) {
+  const typeName = toPascalCase(component.name);
+  const { relations, components: componentDeps } = extractDependencies(component.attributes, typeName);
+  const imports = generateJSDocImports(relations, componentDeps, "component");
+  const properties = generateJSDocProperties(component.attributes);
+  return `/**
+ * ${component.displayName} component
+ * Category: ${component.category}
+ * ${component.description || ""}
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports}
+
+/**
+ * ${component.displayName}
+ * @typedef {Object} ${typeName}
+ * @property {number} id
+${properties}
+ */
+
+// Export empty object to make this a module
+export {};
+`;
+}
+function generateJSDocImports(relations, components, context) {
+  const imports = [];
+  imports.push(`/** @typedef {import('../utils').StrapiMedia} StrapiMedia */`);
+  imports.push(`/** @typedef {import('../utils').BlocksContent} BlocksContent */`);
+  for (const relation of relations) {
+    const typeName = toPascalCase(relation);
+    const fileName = toKebabCase(relation);
+    if (context === "component") {
+      imports.push(`/** @typedef {import('../collections/${fileName}').${typeName}} ${typeName} */`);
+    } else {
+      imports.push(`/** @typedef {import('./${fileName}').${typeName}} ${typeName} */`);
+    }
   }
-  const findOneOptionsFields = [
-    `  populate?: string | string[] | Record<string, unknown>;`
-  ];
-  if (localized) {
-    findOneOptionsFields.push(`  locale?: Locale;`);
+  for (const component of components) {
+    const typeName = toPascalCase(component);
+    const fileName = toKebabCase(component);
+    if (context === "component") {
+      imports.push(`/** @typedef {import('./${fileName}').${typeName}} ${typeName} */`);
+    } else {
+      imports.push(`/** @typedef {import('../components/${fileName}').${typeName}} ${typeName} */`);
+    }
   }
-  if (draftAndPublish) {
-    findOneOptionsFields.push(`  status?: 'draft' | 'published';`);
+  return imports.join("\n");
+}
+function generateJSDocProperties(attributes, components) {
+  const lines = [];
+  for (const [name, attr] of Object.entries(attributes)) {
+    const mappedType = mapAttributeToType(attr);
+    const jsDocType = convertToJSDocType(mappedType.type);
+    const comment = getAttributeComment(attr);
+    const commentPart = comment ? ` - ${comment}` : "";
+    if (attr.required) {
+      lines.push(` * @property {${jsDocType}} ${name}${commentPart}`);
+    } else {
+      lines.push(` * @property {${jsDocType}} [${name}]${commentPart}`);
+    }
   }
-  const findParams = [
-    `      filters: options.filters,`,
-    `      pagination: options.pagination,`,
-    `      sort: options.sort,`,
-    `      populate: options.populate,`
-  ];
-  if (localized) {
-    findParams.push(`      locale: options.locale,`);
+  return lines.join("\n");
+}
+function convertToJSDocType(tsType) {
+  if (tsType.includes(" | null")) {
+    const baseType = tsType.replace(" | null", "");
+    return `${baseType}|null`;
   }
-  if (draftAndPublish) {
-    findParams.push(`      status: options.status,`);
+  if (tsType.endsWith("[]")) {
+    const baseType = tsType.slice(0, -2);
+    if (baseType.startsWith("(") && baseType.endsWith(")")) {
+      return `Array<${baseType.slice(1, -1).replace(/ \| /g, "|")}>`;
+    }
+    return `${baseType}[]`;
   }
-  const findOneParams = [
-    `        populate: options.populate,`
-  ];
-  if (localized) {
-    findOneParams.push(`        locale: options.locale,`);
+  if (tsType.includes("'") && tsType.includes(" | ")) {
+    return "string";
   }
-  if (draftAndPublish) {
-    findOneParams.push(`        status: options.status,`);
+  return tsType;
+}
+
+// src/types/generator.ts
+async function generateTypes(schema, options) {
+  const outputFormat = options.outputFormat ?? "typescript";
+  if (outputFormat === "jsdoc") {
+    return generateJSDocTypes(schema, {
+      outputDir: options.outputDir,
+      blocksRendererInstalled: options.blocksRendererInstalled,
+      strapiVersion: options.strapiVersion
+    });
   }
-  const findBySlugParams = [
-    `      populate: options.populate,`
-  ];
-  if (localized) {
-    findBySlugParams.push(`      locale: options.locale,`);
+  return generateTypeScriptTypes(schema, {
+    outputDir: options.outputDir,
+    blocksRendererInstalled: options.blocksRendererInstalled,
+    strapiVersion: options.strapiVersion
+  });
+}
+async function generateJSDocServices(schema, options) {
+  const { outputDir, typesImportPath, strapiVersion = "v5" } = options;
+  const generatedFiles = [];
+  await ensureDir(outputDir);
+  for (const collection of schema.collections) {
+    const fileName = `${toKebabCase(collection.singularName)}.service.js`;
+    const filePath = path9.join(outputDir, fileName);
+    const content = generateCollectionService(collection, typesImportPath, strapiVersion);
+    await writeFile(filePath, content);
+    generatedFiles.push(filePath);
   }
-  if (draftAndPublish) {
-    findBySlugParams.push(`      status: options.status,`);
+  for (const single of schema.singles) {
+    const fileName = `${toKebabCase(single.singularName)}.service.js`;
+    const filePath = path9.join(outputDir, fileName);
+    const content = generateSingleService(single, typesImportPath, strapiVersion);
+    await writeFile(filePath, content);
+    generatedFiles.push(filePath);
   }
+  return generatedFiles;
+}
+function generateCollectionService(collection, typesImportPath, strapiVersion) {
+  const typeName = toPascalCase(collection.singularName);
+  const serviceName = toCamelCase(collection.singularName) + "Service";
+  const fileName = toKebabCase(collection.singularName);
+  const endpoint = collection.pluralName;
+  const isV4 = strapiVersion === "v4";
+  const idParam = isV4 ? "id" : "documentId";
+  const idType = isV4 ? "number" : "string";
+  const hasSlug = "slug" in collection.attributes;
+  const { localized, draftAndPublish } = collection;
+  const localeOption = localized ? "\n * @property {string} [locale] - Locale code" : "";
+  const statusOption = draftAndPublish ? "\n * @property {'draft'|'published'} [status] - Publication status" : "";
+  const findBySlugMethod = hasSlug ? `
+/**
+ * Find one ${collection.singularName} by slug
+ * @param {string} slug - The slug to search for
+ * @param {FindOneOptions} [options={}] - Query options
+ * @returns {Promise<${typeName}|null>}
+ */
+async findBySlug(slug, options = {}) {
+  const { data } = await this.findMany({
+    filters: { slug: { $eq: slug } },
+    pagination: { pageSize: 1 },
+    populate: options.populate,${localized ? "\n    locale: options.locale," : ""}${draftAndPublish ? "\n    status: options.status," : ""}
+  });
+
+  return data[0] || null;
+},
+` : "";
   return `/**
  * ${collection.displayName} Service
  * ${collection.description || ""}
@@ -657,26 +949,41 @@ function generateCollectionService(collection, typesImportPath, strapiVersion) {
  * Strapi version: ${strapiVersion}
  */
 
-${imports.join("\n")}
+import { collection } from '../client.js';
 
-export interface FindManyOptions {
-${findManyOptionsFields.join("\n")}
-}
+/** @typedef {import('${typesImportPath}/collections/${fileName}').${typeName}} ${typeName} */
+/** @typedef {import('${typesImportPath}/collections/${fileName}').${typeName}Filters} ${typeName}Filters */
+/** @typedef {import('${typesImportPath}/utils').StrapiPagination} StrapiPagination */
+${localized ? `/** @typedef {import('../locales').Locale} Locale */` : ""}
 
-export interface FindOneOptions {
-${findOneOptionsFields.join("\n")}
-}
+/**
+ * @typedef {Object} FindManyOptions
+ * @property {${typeName}Filters} [filters] - Filter conditions
+ * @property {{page?: number, pageSize?: number, start?: number, limit?: number}} [pagination] - Pagination options
+ * @property {string|string[]} [sort] - Sort order
+ * @property {string|string[]|Object} [populate] - Relations to populate${localeOption}${statusOption}
+ */
 
-// Create typed collection helper
-const ${toCamelCase(collection.singularName)}Collection = collection<${typeName}>('${endpoint}');
+/**
+ * @typedef {Object} FindOneOptions
+ * @property {string|string[]|Object} [populate] - Relations to populate${localeOption}${statusOption}
+ */
+
+/** @type {ReturnType<typeof collection<${typeName}>>} */
+const ${toCamelCase(collection.singularName)}Collection = collection('${endpoint}');
 
 export const ${serviceName} = {
   /**
    * Find multiple ${collection.pluralName}
+   * @param {FindManyOptions} [options={}] - Query options
+   * @returns {Promise<{data: ${typeName}[], pagination: StrapiPagination}>}
    */
-  async findMany(options: FindManyOptions = {}): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
+  async findMany(options = {}) {
     const response = await ${toCamelCase(collection.singularName)}Collection.find({
-${findParams.join("\n")}
+      filters: options.filters,
+      pagination: options.pagination,
+      sort: options.sort,
+      populate: options.populate,${localized ? "\n      locale: options.locale," : ""}${draftAndPublish ? "\n      status: options.status," : ""}
     });
 
     return {
@@ -687,9 +994,12 @@ ${findParams.join("\n")}
 
   /**
    * Find all ${collection.pluralName} (handles pagination automatically)
+   * @param {Omit<FindManyOptions, 'pagination'>} [options={}] - Query options
+   * @returns {Promise<${typeName}[]>}
    */
-  async findAll(options: Omit<FindManyOptions, 'pagination'> = {}): Promise<${typeName}[]> {
-    const allItems: ${typeName}[] = [];
+  async findAll(options = {}) {
+    /** @type {${typeName}[]} */
+    const allItems = [];
     let page = 1;
     let hasMore = true;
 
@@ -708,64 +1018,62 @@ ${findParams.join("\n")}
   },
 
   /**
-   * Find one ${collection.singularName} by ${idName}
+   * Find one ${collection.singularName} by ${idParam}
+   * @param {${idType}} ${idParam} - The ${idParam} to find
+   * @param {FindOneOptions} [options={}] - Query options
+   * @returns {Promise<${typeName}|null>}
    */
-  async findOne(${idParam}, options: FindOneOptions = {}): Promise<${typeName} | null> {
+  async findOne(${idParam}, options = {}) {
     try {
-      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idName}, {
-${findOneParams.join("\n")}
+      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idParam}, {
+        populate: options.populate,${localized ? "\n        locale: options.locale," : ""}${draftAndPublish ? "\n        status: options.status," : ""}
       });
 
       return response.data;
     } catch (error) {
-      // Return null if not found
       if (error instanceof Error && error.message.includes('404')) {
         return null;
       }
       throw error;
     }
   },
-${hasSlug ? `
-  /**
-   * Find one ${collection.singularName} by slug
-   */
-  async findBySlug(slug: string, options: FindOneOptions = {}): Promise<${typeName} | null> {
-    const { data } = await this.findMany({
-      filters: { slug: { $eq: slug } } as ${typeName}Filters,
-      pagination: { pageSize: 1 },
-${findBySlugParams.join("\n")}
-    });
-
-    return data[0] || null;
-  },
-` : ""}
+${findBySlugMethod}
   /**
    * Create a new ${collection.singularName}
+   * @param {Partial<${typeName}>} data - The data to create
+   * @returns {Promise<${typeName}>}
    */
-  async create(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+  async create(data) {
     const response = await ${toCamelCase(collection.singularName)}Collection.create({ data });
     return response.data;
   },
 
   /**
    * Update a ${collection.singularName}
+   * @param {${idType}} ${idParam} - The ${idParam} to update
+   * @param {Partial<${typeName}>} data - The data to update
+   * @returns {Promise<${typeName}>}
    */
-  async update(${idParam}, data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
-    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idName}, { data });
+  async update(${idParam}, data) {
+    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idParam}, { data });
     return response.data;
   },
 
   /**
    * Delete a ${collection.singularName}
+   * @param {${idType}} ${idParam} - The ${idParam} to delete
+   * @returns {Promise<void>}
    */
-  async delete(${idParam}): Promise<void> {
-    await ${toCamelCase(collection.singularName)}Collection.delete(${idName});
+  async delete(${idParam}) {
+    await ${toCamelCase(collection.singularName)}Collection.delete(${idParam});
   },
 
   /**
    * Count ${collection.pluralName}
+   * @param {${typeName}Filters} [filters] - Filter conditions
+   * @returns {Promise<number>}
    */
-  async count(filters?: ${typeName}Filters): Promise<number> {
+  async count(filters) {
     const { pagination } = await this.findMany({
       filters,
       pagination: { pageSize: 1 },
@@ -781,34 +1089,9 @@ function generateSingleService(single, typesImportPath, strapiVersion) {
   const serviceName = toCamelCase(single.singularName) + "Service";
   const fileName = toKebabCase(single.singularName);
   const endpoint = single.singularName;
-  const isV4 = strapiVersion === "v4";
-  const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt'";
   const { localized, draftAndPublish } = single;
-  const imports = [
-    `import { single } from '../client';`,
-    `import type { ${typeName} } from '${typesImportPath}/collections/${fileName}';`
-  ];
-  if (localized) {
-    imports.push(`import type { Locale } from '../locales';`);
-  }
-  const findOptionsFields = [
-    `  populate?: string | string[] | Record<string, unknown>;`
-  ];
-  if (localized) {
-    findOptionsFields.push(`  locale?: Locale;`);
-  }
-  if (draftAndPublish) {
-    findOptionsFields.push(`  status?: 'draft' | 'published';`);
-  }
-  const findParams = [
-    `        populate: options.populate,`
-  ];
-  if (localized) {
-    findParams.push(`        locale: options.locale,`);
-  }
-  if (draftAndPublish) {
-    findParams.push(`        status: options.status,`);
-  }
+  const localeOption = localized ? "\n * @property {string} [locale] - Locale code" : "";
+  const statusOption = draftAndPublish ? "\n * @property {'draft'|'published'} [status] - Publication status" : "";
   return `/**
  * ${single.displayName} Service (Single Type)
  * ${single.description || ""}
@@ -816,23 +1099,29 @@ function generateSingleService(single, typesImportPath, strapiVersion) {
  * Strapi version: ${strapiVersion}
  */
 
-${imports.join("\n")}
+import { single } from '../client.js';
 
-export interface FindOptions {
-${findOptionsFields.join("\n")}
-}
+/** @typedef {import('${typesImportPath}/collections/${fileName}').${typeName}} ${typeName} */
+${localized ? `/** @typedef {import('../locales').Locale} Locale */` : ""}
 
-// Create typed single helper
-const ${toCamelCase(single.singularName)}Single = single<${typeName}>('${endpoint}');
+/**
+ * @typedef {Object} FindOptions
+ * @property {string|string[]|Object} [populate] - Relations to populate${localeOption}${statusOption}
+ */
+
+/** @type {ReturnType<typeof single<${typeName}>>} */
+const ${toCamelCase(single.singularName)}Single = single('${endpoint}');
 
 export const ${serviceName} = {
   /**
    * Get ${single.displayName}
+   * @param {FindOptions} [options={}] - Query options
+   * @returns {Promise<${typeName}|null>}
    */
-  async find(options: FindOptions = {}): Promise<${typeName} | null> {
+  async find(options = {}) {
     try {
       const response = await ${toCamelCase(single.singularName)}Single.find({
-${findParams.join("\n")}
+        populate: options.populate,${localized ? "\n        locale: options.locale," : ""}${draftAndPublish ? "\n        status: options.status," : ""}
       });
 
       return response.data;
@@ -846,249 +1135,388 @@ ${findParams.join("\n")}
 
   /**
    * Update ${single.displayName}
+   * @param {Partial<${typeName}>} data - The data to update
+   * @returns {Promise<${typeName}>}
    */
-  async update(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+  async update(data) {
     const response = await ${toCamelCase(single.singularName)}Single.update({ data });
     return response.data;
   },
 
   /**
    * Delete ${single.displayName}
+   * @returns {Promise<void>}
    */
-  async delete(): Promise<void> {
+  async delete() {
     await ${toCamelCase(single.singularName)}Single.delete();
   },
 };
 `;
 }
-async function generateActions(schema, options) {
-  const { outputDir, servicesImportPath, strapiVersion = "v5" } = options;
+
+// src/services/generator.ts
+async function generateServices(schema, options) {
+  const outputFormat = options.outputFormat ?? "typescript";
+  if (outputFormat === "jsdoc") {
+    return generateJSDocServices(schema, {
+      outputDir: options.outputDir,
+      typesImportPath: options.typesImportPath,
+      strapiVersion: options.strapiVersion
+    });
+  }
+  return generateTypeScriptServices(schema, options);
+}
+async function generateTypeScriptServices(schema, options) {
+  const { outputDir, typesImportPath, strapiVersion = "v5" } = options;
   const generatedFiles = [];
   await ensureDir(outputDir);
   for (const collection of schema.collections) {
-    const fileName = `${toKebabCase(collection.singularName)}.ts`;
-    const filePath = path7.join(outputDir, fileName);
-    const content = generateCollectionActions(collection, servicesImportPath, strapiVersion);
+    const fileName = `${toKebabCase(collection.singularName)}.service.ts`;
+    const filePath = path9.join(outputDir, fileName);
+    const content = generateCollectionService2(collection, typesImportPath, strapiVersion);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
   }
   for (const single of schema.singles) {
-    const fileName = `${toKebabCase(single.singularName)}.ts`;
-    const filePath = path7.join(outputDir, fileName);
-    const content = generateSingleActions(single, servicesImportPath);
+    const fileName = `${toKebabCase(single.singularName)}.service.ts`;
+    const filePath = path9.join(outputDir, fileName);
+    const content = generateSingleService2(single, typesImportPath, strapiVersion);
     await writeFile(filePath, await formatCode(content));
     generatedFiles.push(filePath);
   }
   return generatedFiles;
 }
-function generateCollectionActions(collection, servicesImportPath, strapiVersion) {
+function generateCollectionService2(collection, typesImportPath, strapiVersion) {
+  const typeName = toPascalCase(collection.singularName);
   const serviceName = toCamelCase(collection.singularName) + "Service";
-  const actionsName = toCamelCase(collection.singularName);
   const fileName = toKebabCase(collection.singularName);
+  const endpoint = collection.pluralName;
   const isV4 = strapiVersion === "v4";
-  const idInputSchema = isV4 ? "z.number().int().positive()" : "z.string().min(1)";
-  const idParamName = isV4 ? "id" : "documentId";
-  const idComment = isV4 ? "id" : "documentId";
+  const idParam = isV4 ? "id: number" : "documentId: string";
+  const idName = isV4 ? "id" : "documentId";
+  const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt' | 'publishedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt' | 'publishedAt'";
   const hasSlug = "slug" in collection.attributes;
+  const { localized, draftAndPublish } = collection;
+  const imports = [
+    `import { collection } from '../client';`,
+    `import type { ${typeName}, ${typeName}Filters } from '${typesImportPath}/collections/${fileName}';`,
+    `import type { StrapiPagination } from '${typesImportPath}/utils';`
+  ];
+  if (localized) {
+    imports.push(`import type { Locale } from '../locales';`);
+  }
+  const findManyOptionsFields = [
+    `  filters?: ${typeName}Filters;`,
+    `  pagination?: {`,
+    `    /** Page number (1-indexed) - use with pageSize */`,
+    `    page?: number;`,
+    `    /** Number of items per page (default: 25) - use with page */`,
+    `    pageSize?: number;`,
+    `    /** Offset to start from (0-indexed) - use with limit */`,
+    `    start?: number;`,
+    `    /** Maximum number of items to return - use with start */`,
+    `    limit?: number;`,
+    `  };`,
+    `  sort?: string | string[];`,
+    `  populate?: string | string[] | Record<string, unknown>;`
+  ];
+  if (localized) {
+    findManyOptionsFields.push(`  locale?: Locale;`);
+  }
+  if (draftAndPublish) {
+    findManyOptionsFields.push(`  status?: 'draft' | 'published';`);
+  }
+  const findOneOptionsFields = [
+    `  populate?: string | string[] | Record<string, unknown>;`
+  ];
+  if (localized) {
+    findOneOptionsFields.push(`  locale?: Locale;`);
+  }
+  if (draftAndPublish) {
+    findOneOptionsFields.push(`  status?: 'draft' | 'published';`);
+  }
+  const findParams = [
+    `      filters: options.filters,`,
+    `      pagination: options.pagination,`,
+    `      sort: options.sort,`,
+    `      populate: options.populate,`
+  ];
+  if (localized) {
+    findParams.push(`      locale: options.locale,`);
+  }
+  if (draftAndPublish) {
+    findParams.push(`      status: options.status,`);
+  }
+  const findOneParams = [
+    `        populate: options.populate,`
+  ];
+  if (localized) {
+    findOneParams.push(`        locale: options.locale,`);
+  }
+  if (draftAndPublish) {
+    findOneParams.push(`        status: options.status,`);
+  }
+  const findBySlugParams = [
+    `      populate: options.populate,`
+  ];
+  if (localized) {
+    findBySlugParams.push(`      locale: options.locale,`);
+  }
+  if (draftAndPublish) {
+    findBySlugParams.push(`      status: options.status,`);
+  }
   return `/**
- * ${collection.displayName} Actions
+ * ${collection.displayName} Service
  * ${collection.description || ""}
  * Generated by strapi2front
  * Strapi version: ${strapiVersion}
  */
 
-import { defineAction, ActionError } from 'astro:actions';
-import { z } from 'astro:schema';
-import { ${serviceName} } from '${servicesImportPath}/${fileName}.service';
+${imports.join("\n")}
 
-/**
- * Pagination input schema
- */
-const paginationSchema = z.object({
-  page: z.number().int().positive().optional().default(1),
-  pageSize: z.number().int().positive().max(100).optional().default(25),
-}).optional();
+export interface FindManyOptions {
+${findManyOptionsFields.join("\n")}
+}
 
-/**
- * ${collection.displayName} actions
- */
-export const ${actionsName} = {
+export interface FindOneOptions {
+${findOneOptionsFields.join("\n")}
+}
+
+// Create typed collection helper
+const ${toCamelCase(collection.singularName)}Collection = collection<${typeName}>('${endpoint}');
+
+export const ${serviceName} = {
   /**
-   * Get all ${collection.pluralName} with pagination
+   * Find multiple ${collection.pluralName}
    */
-  getAll: defineAction({
-    input: z.object({
-      pagination: paginationSchema,
-      sort: z.union([z.string(), z.array(z.string())]).optional(),
-    }).optional(),
-    handler: async (input) => {
-      try {
-        const result = await ${serviceName}.findMany({
-          pagination: input?.pagination,
-          sort: input?.sort,
-        });
+  async findMany(options: FindManyOptions = {}): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.find({
+${findParams.join("\n")}
+    });
 
-        return result;
-      } catch (error) {
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to fetch ${collection.pluralName}',
-        });
-      }
-    },
-  }),
+    return {
+      data: response.data,
+      pagination: response.meta.pagination,
+    };
+  },
 
   /**
-   * Get a single ${collection.singularName} by ${idComment}
+   * Find all ${collection.pluralName} (handles pagination automatically)
    */
-  getOne: defineAction({
-    input: z.object({
-      ${idParamName}: ${idInputSchema},
-      populate: z.union([z.string(), z.array(z.string())]).optional(),
-    }),
-    handler: async ({ ${idParamName}, populate }) => {
-      try {
-        const result = await ${serviceName}.findOne(${idParamName}, { populate });
+  async findAll(options: Omit<FindManyOptions, 'pagination'> = {}): Promise<${typeName}[]> {
+    const allItems: ${typeName}[] = [];
+    let page = 1;
+    let hasMore = true;
 
-        if (!result) {
-          throw new ActionError({
-            code: 'NOT_FOUND',
-            message: '${collection.displayName} not found',
-          });
-        }
+    while (hasMore) {
+      const { data, pagination } = await this.findMany({
+        ...options,
+        pagination: { page, pageSize: 100 },
+      });
 
-        return result;
-      } catch (error) {
-        if (error instanceof ActionError) throw error;
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to fetch ${collection.singularName}',
-        });
+      allItems.push(...data);
+      hasMore = page < pagination.pageCount;
+      page++;
+    }
+
+    return allItems;
+  },
+
+  /**
+   * Find one ${collection.singularName} by ${idName}
+   */
+  async findOne(${idParam}, options: FindOneOptions = {}): Promise<${typeName} | null> {
+    try {
+      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idName}, {
+${findOneParams.join("\n")}
+      });
+
+      return response.data;
+    } catch (error) {
+      // Return null if not found
+      if (error instanceof Error && error.message.includes('404')) {
+        return null;
       }
-    },
-  }),
+      throw error;
+    }
+  },
 ${hasSlug ? `
   /**
-   * Get a single ${collection.singularName} by slug
+   * Find one ${collection.singularName} by slug
    */
-  getBySlug: defineAction({
-    input: z.object({
-      slug: z.string().min(1),
-      populate: z.union([z.string(), z.array(z.string())]).optional(),
-    }),
-    handler: async ({ slug, populate }) => {
-      try {
-        const result = await ${serviceName}.findBySlug(slug, { populate });
-
-        if (!result) {
-          throw new ActionError({
-            code: 'NOT_FOUND',
-            message: '${collection.displayName} not found',
-          });
-        }
+  async findBySlug(slug: string, options: FindOneOptions = {}): Promise<${typeName} | null> {
+    const { data } = await this.findMany({
+      filters: { slug: { $eq: slug } } as ${typeName}Filters,
+      pagination: { pageSize: 1 },
+${findBySlugParams.join("\n")}
+    });
 
-        return result;
-      } catch (error) {
-        if (error instanceof ActionError) throw error;
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to fetch ${collection.singularName}',
-        });
-      }
-    },
-  }),
+    return data[0] || null;
+  },
 ` : ""}
   /**
    * Create a new ${collection.singularName}
    */
-  create: defineAction({
-    input: z.object({
-      data: z.record(z.unknown()),
-    }),
-    handler: async ({ data }) => {
-      try {
-        const result = await ${serviceName}.create(data);
-        return result;
-      } catch (error) {
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to create ${collection.singularName}',
-        });
-      }
-    },
-  }),
+  async create(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.create({ data });
+    return response.data;
+  },
 
   /**
    * Update a ${collection.singularName}
    */
-  update: defineAction({
-    input: z.object({
-      ${idParamName}: ${idInputSchema},
-      data: z.record(z.unknown()),
-    }),
-    handler: async ({ ${idParamName}, data }) => {
-      try {
-        const result = await ${serviceName}.update(${idParamName}, data);
-        return result;
-      } catch (error) {
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to update ${collection.singularName}',
-        });
-      }
-    },
-  }),
+  async update(${idParam}, data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idName}, { data });
+    return response.data;
+  },
 
   /**
    * Delete a ${collection.singularName}
    */
-  delete: defineAction({
-    input: z.object({
-      ${idParamName}: ${idInputSchema},
-    }),
-    handler: async ({ ${idParamName} }) => {
-      try {
-        await ${serviceName}.delete(${idParamName});
-        return { success: true };
-      } catch (error) {
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to delete ${collection.singularName}',
-        });
-      }
-    },
-  }),
+  async delete(${idParam}): Promise<void> {
+    await ${toCamelCase(collection.singularName)}Collection.delete(${idName});
+  },
 
   /**
    * Count ${collection.pluralName}
    */
-  count: defineAction({
-    input: z.object({
-      filters: z.record(z.unknown()).optional(),
-    }).optional(),
-    handler: async (input) => {
-      try {
-        const count = await ${serviceName}.count(input?.filters as any);
-        return { count };
-      } catch (error) {
-        throw new ActionError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to count ${collection.pluralName}',
-        });
-      }
-    },
-  }),
+  async count(filters?: ${typeName}Filters): Promise<number> {
+    const { pagination } = await this.findMany({
+      filters,
+      pagination: { pageSize: 1 },
+    });
+
+    return pagination.total;
+  },
 };
 `;
 }
-function generateSingleActions(single, servicesImportPath) {
+function generateSingleService2(single, typesImportPath, strapiVersion) {
+  const typeName = toPascalCase(single.singularName);
   const serviceName = toCamelCase(single.singularName) + "Service";
-  const actionsName = toCamelCase(single.singularName);
   const fileName = toKebabCase(single.singularName);
+  const endpoint = single.singularName;
+  const isV4 = strapiVersion === "v4";
+  const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt'";
+  const { localized, draftAndPublish } = single;
+  const imports = [
+    `import { single } from '../client';`,
+    `import type { ${typeName} } from '${typesImportPath}/collections/${fileName}';`
+  ];
+  if (localized) {
+    imports.push(`import type { Locale } from '../locales';`);
+  }
+  const findOptionsFields = [
+    `  populate?: string | string[] | Record<string, unknown>;`
+  ];
+  if (localized) {
+    findOptionsFields.push(`  locale?: Locale;`);
+  }
+  if (draftAndPublish) {
+    findOptionsFields.push(`  status?: 'draft' | 'published';`);
+  }
+  const findParams = [
+    `        populate: options.populate,`
+  ];
+  if (localized) {
+    findParams.push(`        locale: options.locale,`);
+  }
+  if (draftAndPublish) {
+    findParams.push(`        status: options.status,`);
+  }
   return `/**
- * ${single.displayName} Actions (Single Type)
+ * ${single.displayName} Service (Single Type)
  * ${single.description || ""}
  * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports.join("\n")}
+
+export interface FindOptions {
+${findOptionsFields.join("\n")}
+}
+
+// Create typed single helper
+const ${toCamelCase(single.singularName)}Single = single<${typeName}>('${endpoint}');
+
+export const ${serviceName} = {
+  /**
+   * Get ${single.displayName}
+   */
+  async find(options: FindOptions = {}): Promise<${typeName} | null> {
+    try {
+      const response = await ${toCamelCase(single.singularName)}Single.find({
+${findParams.join("\n")}
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('404')) {
+        return null;
+      }
+      throw error;
+    }
+  },
+
+  /**
+   * Update ${single.displayName}
+   */
+  async update(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+    const response = await ${toCamelCase(single.singularName)}Single.update({ data });
+    return response.data;
+  },
+
+  /**
+   * Delete ${single.displayName}
+   */
+  async delete(): Promise<void> {
+    await ${toCamelCase(single.singularName)}Single.delete();
+  },
+};
+`;
+}
+function isAstroActionsSupported(astroVersion) {
+  if (!astroVersion) return false;
+  const match = astroVersion.replace(/^[\^~]/, "").match(/^(\d+)/);
+  const majorVersion = match ? parseInt(match[1], 10) : null;
+  return majorVersion !== null && majorVersion >= 4;
+}
+async function generateAstroActions(schema, options) {
+  const { outputDir, servicesImportPath, strapiVersion = "v5" } = 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);
+    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);
+    await writeFile(filePath, await formatCode(content));
+    generatedFiles.push(filePath);
+  }
+  return generatedFiles;
+}
+function generateCollectionActions(collection, servicesImportPath, strapiVersion) {
+  const serviceName = toCamelCase(collection.singularName) + "Service";
+  const actionsName = toCamelCase(collection.singularName);
+  const fileName = toKebabCase(collection.singularName);
+  const isV4 = strapiVersion === "v4";
+  const idInputSchema = isV4 ? "z.number().int().positive()" : "z.string().min(1)";
+  const idParamName = isV4 ? "id" : "documentId";
+  const idComment = isV4 ? "id" : "documentId";
+  const hasSlug = "slug" in collection.attributes;
+  return `/**
+ * ${collection.displayName} Actions
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ * Framework: Astro
+ * Strapi version: ${strapiVersion}
  */
 
 import { defineAction, ActionError } from 'astro:actions';
@@ -1096,26 +1524,58 @@ import { z } from 'astro:schema';
 import { ${serviceName} } from '${servicesImportPath}/${fileName}.service';
 
 /**
- * ${single.displayName} actions
+ * Pagination input schema
+ */
+const paginationSchema = z.object({
+  page: z.number().int().positive().optional().default(1),
+  pageSize: z.number().int().positive().max(100).optional().default(25),
+}).optional();
+
+/**
+ * ${collection.displayName} actions
  */
 export const ${actionsName} = {
   /**
-   * Get ${single.displayName}
+   * Get all ${collection.pluralName} with pagination
    */
-  get: defineAction({
+  getAll: defineAction({
     input: z.object({
-      populate: z.union([z.string(), z.array(z.string())]).optional(),
+      pagination: paginationSchema,
+      sort: z.union([z.string(), z.array(z.string())]).optional(),
     }).optional(),
     handler: async (input) => {
       try {
-        const result = await ${serviceName}.find({
-          populate: input?.populate,
+        const result = await ${serviceName}.findMany({
+          pagination: input?.pagination,
+          sort: input?.sort,
         });
 
+        return result;
+      } catch (error) {
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to fetch ${collection.pluralName}',
+        });
+      }
+    },
+  }),
+
+  /**
+   * Get a single ${collection.singularName} by ${idComment}
+   */
+  getOne: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+      populate: z.union([z.string(), z.array(z.string())]).optional(),
+    }),
+    handler: async ({ ${idParamName}, populate }) => {
+      try {
+        const result = await ${serviceName}.findOne(${idParamName}, { populate });
+
         if (!result) {
           throw new ActionError({
             code: 'NOT_FOUND',
-            message: '${single.displayName} not found',
+            message: '${collection.displayName} not found',
           });
         }
 
@@ -1124,22 +1584,185 @@ export const ${actionsName} = {
         if (error instanceof ActionError) throw error;
         throw new ActionError({
           code: 'INTERNAL_SERVER_ERROR',
-          message: error instanceof Error ? error.message : 'Failed to fetch ${single.singularName}',
+          message: error instanceof Error ? error.message : 'Failed to fetch ${collection.singularName}',
         });
       }
     },
   }),
-
+${hasSlug ? `
   /**
-   * Update ${single.displayName}
+   * Get a single ${collection.singularName} by slug
    */
-  update: defineAction({
+  getBySlug: defineAction({
     input: z.object({
-      data: z.record(z.unknown()),
+      slug: z.string().min(1),
+      populate: z.union([z.string(), z.array(z.string())]).optional(),
     }),
-    handler: async ({ data }) => {
+    handler: async ({ slug, populate }) => {
       try {
-        const result = await ${serviceName}.update(data);
+        const result = await ${serviceName}.findBySlug(slug, { populate });
+
+        if (!result) {
+          throw new ActionError({
+            code: 'NOT_FOUND',
+            message: '${collection.displayName} not found',
+          });
+        }
+
+        return result;
+      } catch (error) {
+        if (error instanceof ActionError) throw error;
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to fetch ${collection.singularName}',
+        });
+      }
+    },
+  }),
+` : ""}
+  /**
+   * Create a new ${collection.singularName}
+   */
+  create: defineAction({
+    input: z.object({
+      data: z.record(z.unknown()),
+    }),
+    handler: async ({ data }) => {
+      try {
+        const result = await ${serviceName}.create(data);
+        return result;
+      } catch (error) {
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to create ${collection.singularName}',
+        });
+      }
+    },
+  }),
+
+  /**
+   * Update a ${collection.singularName}
+   */
+  update: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+      data: z.record(z.unknown()),
+    }),
+    handler: async ({ ${idParamName}, data }) => {
+      try {
+        const result = await ${serviceName}.update(${idParamName}, data);
+        return result;
+      } catch (error) {
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to update ${collection.singularName}',
+        });
+      }
+    },
+  }),
+
+  /**
+   * Delete a ${collection.singularName}
+   */
+  delete: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+    }),
+    handler: async ({ ${idParamName} }) => {
+      try {
+        await ${serviceName}.delete(${idParamName});
+        return { success: true };
+      } catch (error) {
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to delete ${collection.singularName}',
+        });
+      }
+    },
+  }),
+
+  /**
+   * Count ${collection.pluralName}
+   */
+  count: defineAction({
+    input: z.object({
+      filters: z.record(z.unknown()).optional(),
+    }).optional(),
+    handler: async (input) => {
+      try {
+        const count = await ${serviceName}.count(input?.filters as any);
+        return { count };
+      } catch (error) {
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to count ${collection.pluralName}',
+        });
+      }
+    },
+  }),
+};
+`;
+}
+function generateSingleActions(single, servicesImportPath) {
+  const serviceName = toCamelCase(single.singularName) + "Service";
+  const actionsName = toCamelCase(single.singularName);
+  const fileName = toKebabCase(single.singularName);
+  return `/**
+ * ${single.displayName} Actions (Single Type)
+ * ${single.description || ""}
+ * Generated by strapi2front
+ * Framework: Astro
+ */
+
+import { defineAction, ActionError } from 'astro:actions';
+import { z } from 'astro:schema';
+import { ${serviceName} } from '${servicesImportPath}/${fileName}.service';
+
+/**
+ * ${single.displayName} actions
+ */
+export const ${actionsName} = {
+  /**
+   * Get ${single.displayName}
+   */
+  get: defineAction({
+    input: z.object({
+      populate: z.union([z.string(), z.array(z.string())]).optional(),
+    }).optional(),
+    handler: async (input) => {
+      try {
+        const result = await ${serviceName}.find({
+          populate: input?.populate,
+        });
+
+        if (!result) {
+          throw new ActionError({
+            code: 'NOT_FOUND',
+            message: '${single.displayName} not found',
+          });
+        }
+
+        return result;
+      } catch (error) {
+        if (error instanceof ActionError) throw error;
+        throw new ActionError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to fetch ${single.singularName}',
+        });
+      }
+    },
+  }),
+
+  /**
+   * Update ${single.displayName}
+   */
+  update: defineAction({
+    input: z.object({
+      data: z.record(z.unknown()),
+    }),
+    handler: async ({ data }) => {
+      try {
+        const result = await ${serviceName}.update(data);
         return result;
       } catch (error) {
         throw new ActionError({
@@ -1152,11 +1775,20 @@ export const ${actionsName} = {
 };
 `;
 }
+
+// src/actions/generator.ts
+async function generateActions(schema, options) {
+  return generateAstroActions(schema, {
+    outputDir: options.outputDir,
+    servicesImportPath: options.servicesImportPath,
+    strapiVersion: options.strapiVersion
+  });
+}
 async function generateClient(options) {
   const { outputDir, strapiVersion = "v5", apiPrefix = "/api" } = options;
   const generatedFiles = [];
   await ensureDir(outputDir);
-  const filePath = path7.join(outputDir, "client.ts");
+  const filePath = path9.join(outputDir, "client.ts");
   const content = generateClientFile(strapiVersion, apiPrefix);
   await writeFile(filePath, await formatCode(content));
   generatedFiles.push(filePath);
@@ -1426,7 +2058,7 @@ async function generateLocales(locales, options) {
   const { outputDir } = options;
   const generatedFiles = [];
   await ensureDir(outputDir);
-  const filePath = path7.join(outputDir, "locales.ts");
+  const filePath = path9.join(outputDir, "locales.ts");
   const content = generateLocalesFile(locales);
   await writeFile(filePath, await formatCode(content));
   generatedFiles.push(filePath);
@@ -1469,203 +2101,1196 @@ export const locales = [${localeArray}] as const;
  */
 export type Locale = ${localeCodes};
 
-/**
- * Default locale
- */
-export const defaultLocale: Locale = '${defaultLocale}';
+/**
+ * Default locale
+ */
+export const defaultLocale: Locale = '${defaultLocale}';
+
+/**
+ * Locale display names
+ */
+export const localeNames: Record<Locale, string> = {
+${localeNames}
+};
+
+/**
+ * Check if a string is a valid locale
+ */
+export function isValidLocale(code: string): code is Locale {
+  return locales.includes(code as Locale);
+}
+
+/**
+ * Get locale name by code
+ */
+export function getLocaleName(code: Locale): string {
+  return localeNames[code] || code;
+}
+`;
+}
+async function generateByFeature(schema, locales, options) {
+  const {
+    outputDir,
+    features,
+    blocksRendererInstalled = false,
+    strapiVersion = "v5",
+    apiPrefix = "/api",
+    outputFormat = "typescript"
+  } = options;
+  const generatedFiles = [];
+  const ext = outputFormat === "jsdoc" ? "js" : "ts";
+  await ensureDir(path9.join(outputDir, "collections"));
+  await ensureDir(path9.join(outputDir, "singles"));
+  await ensureDir(path9.join(outputDir, "components"));
+  await ensureDir(path9.join(outputDir, "shared"));
+  const sharedDir = path9.join(outputDir, "shared");
+  const utilsPath = path9.join(sharedDir, `utils.${ext}`);
+  const utilsContent = outputFormat === "jsdoc" ? generateUtilityTypesJSDoc(blocksRendererInstalled, strapiVersion) : generateUtilityTypes3(blocksRendererInstalled, strapiVersion);
+  await writeFile(utilsPath, await formatCode(utilsContent));
+  generatedFiles.push(utilsPath);
+  const clientPath = path9.join(sharedDir, `client.${ext}`);
+  const clientContent = outputFormat === "jsdoc" ? generateClientJSDoc(strapiVersion, apiPrefix) : generateClient2(strapiVersion, apiPrefix);
+  await writeFile(clientPath, await formatCode(clientContent));
+  generatedFiles.push(clientPath);
+  const localesPath = path9.join(sharedDir, `locales.${ext}`);
+  const localesContent = outputFormat === "jsdoc" ? generateLocalesFileJSDoc(locales) : generateLocalesFile2(locales);
+  await writeFile(localesPath, await formatCode(localesContent));
+  generatedFiles.push(localesPath);
+  for (const collection of schema.collections) {
+    const featureDir = path9.join(outputDir, "collections", toKebabCase(collection.singularName));
+    await ensureDir(featureDir);
+    if (features.types) {
+      const typesPath = path9.join(featureDir, `types.${ext}`);
+      const content = outputFormat === "jsdoc" ? generateCollectionTypesJSDoc(collection, schema) : generateCollectionTypes(collection, schema);
+      await writeFile(typesPath, await formatCode(content));
+      generatedFiles.push(typesPath);
+    }
+    if (features.services) {
+      const servicePath = path9.join(featureDir, `service.${ext}`);
+      const content = outputFormat === "jsdoc" ? generateCollectionServiceJSDoc(collection, strapiVersion) : generateCollectionService3(collection, strapiVersion);
+      await writeFile(servicePath, await formatCode(content));
+      generatedFiles.push(servicePath);
+    }
+    if (features.actions) {
+      const actionsPath = path9.join(featureDir, `actions.${ext}`);
+      await writeFile(actionsPath, await formatCode(generateCollectionActions2(collection, strapiVersion)));
+      generatedFiles.push(actionsPath);
+    }
+  }
+  for (const single of schema.singles) {
+    const featureDir = path9.join(outputDir, "singles", toKebabCase(single.singularName));
+    await ensureDir(featureDir);
+    if (features.types) {
+      const typesPath = path9.join(featureDir, `types.${ext}`);
+      const content = outputFormat === "jsdoc" ? generateSingleTypesJSDoc(single, schema) : generateSingleTypes(single, schema);
+      await writeFile(typesPath, await formatCode(content));
+      generatedFiles.push(typesPath);
+    }
+    if (features.services) {
+      const servicePath = path9.join(featureDir, `service.${ext}`);
+      const content = outputFormat === "jsdoc" ? generateSingleServiceJSDoc(single, strapiVersion) : generateSingleService3(single, strapiVersion);
+      await writeFile(servicePath, await formatCode(content));
+      generatedFiles.push(servicePath);
+    }
+  }
+  for (const component of schema.components) {
+    const componentPath = path9.join(outputDir, "components", `${toKebabCase(component.name)}.${ext}`);
+    const content = outputFormat === "jsdoc" ? generateComponentTypesJSDoc(component, schema) : generateComponentTypes(component, schema);
+    await writeFile(componentPath, await formatCode(content));
+    generatedFiles.push(componentPath);
+  }
+  return generatedFiles;
+}
+function generateUtilityTypes3(blocksRendererInstalled, strapiVersion) {
+  const isV4 = strapiVersion === "v4";
+  const blocksContentType = isV4 ? `/**
+ * Rich text content (Strapi v4)
+ * Can be markdown string or custom JSON structure
+ */
+export type RichTextContent = string;` : blocksRendererInstalled ? `/**
+ * Blocks content type (Strapi v5 rich text)
+ * Re-exported from @strapi/blocks-react-renderer
+ */
+export type { BlocksContent } from '@strapi/blocks-react-renderer';` : `/**
+ * Blocks content type (Strapi v5 rich text)
+ *
+ * For full type support and rendering, install:
+ * npm install @strapi/blocks-react-renderer
+ *
+ * Then re-run: npx strapi2front sync
+ */
+export type BlocksContent = unknown[];`;
+  const baseEntity = isV4 ? `export interface StrapiBaseEntity {
+  id: number;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string | null;
+}` : `export interface StrapiBaseEntity {
+  id: number;
+  documentId: string;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string | null;
+}`;
+  const mediaType = isV4 ? `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;
+}` : `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;
+}`;
+  const v4RawResponseTypes = isV4 ? `
+
+/**
+ * Strapi v4 raw API response (with nested attributes)
+ */
+export interface StrapiV4RawItem<T> {
+  id: number;
+  attributes: Omit<T, 'id'>;
+}
+
+export interface StrapiV4RawResponse<T> {
+  data: StrapiV4RawItem<T>;
+  meta: Record<string, unknown>;
+}
+
+export interface StrapiV4RawListResponse<T> {
+  data: StrapiV4RawItem<T>[];
+  meta: {
+    pagination: StrapiPagination;
+  };
+}
+
+/**
+ * Flatten Strapi v4 response item
+ */
+export function flattenV4Response<T>(item: StrapiV4RawItem<T>): T {
+  return { id: item.id, ...item.attributes } as T;
+}
+
+/**
+ * Flatten Strapi v4 list response
+ */
+export function flattenV4ListResponse<T>(items: StrapiV4RawItem<T>[]): T[] {
+  return items.map(item => flattenV4Response<T>(item));
+}` : "";
+  return `/**
+ * Strapi utility types
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${mediaType}
+
+export interface StrapiMediaFormat {
+  name: string;
+  hash: string;
+  ext: string;
+  mime: string;
+  width: number;
+  height: number;
+  size: number;
+  url: string;
+}
+
+export interface StrapiPagination {
+  page: number;
+  pageSize: number;
+  pageCount: number;
+  total: number;
+}
+
+export interface StrapiResponse<T> {
+  data: T;
+  meta: {
+    pagination?: StrapiPagination;
+  };
+}
+
+export interface StrapiListResponse<T> {
+  data: T[];
+  meta: {
+    pagination: StrapiPagination;
+  };
+}
+
+${baseEntity}
+${v4RawResponseTypes}
+${blocksContentType}
+`;
+}
+function generateClient2(strapiVersion, apiPrefix = "/api") {
+  const isV4 = strapiVersion === "v4";
+  const normalizedPrefix = apiPrefix.startsWith("/") ? apiPrefix : "/" + apiPrefix;
+  if (isV4) {
+    return `/**
+ * Strapi Client (v4)
+ * Generated by strapi2front
+ */
+
+import Strapi from 'strapi-sdk-js';
+import type { StrapiPagination } 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 pagination for fallback
+const defaultPagination: StrapiPagination = {
+  page: 1,
+  pageSize: 25,
+  pageCount: 1,
+  total: 0,
+};
+
+// Strapi v4 raw response types (with nested attributes)
+interface StrapiV4RawItem<T> {
+  id: number;
+  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)
+ */
+function flattenItem<T>(item: StrapiV4RawItem<T>): T {
+  return { id: item.id, ...item.attributes } as T;
+}
+
+/**
+ * Recursively flatten nested relations in Strapi v4 response
+ */
+function flattenRelations<T>(data: T): T {
+  if (data === null || data === undefined) return data;
+  if (Array.isArray(data)) {
+    return data.map(item => flattenRelations(item)) as unknown as 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);
+        }
+      } else {
+        result[key] = flattenRelations(value);
+      }
+    }
+    return result as T;
+  }
+  return data;
+}
+
+// Helper to get typed collection
+export function collection<T>(pluralName: string) {
+  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 flattenedData = Array.isArray(response.data)
+        ? response.data.map(item => flattenRelations(flattenItem<T>(item)))
+        : [];
+      return {
+        data: flattenedData,
+        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>;
+      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>;
+      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>;
+      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    },
+    async delete(id: number | string): Promise<void> {
+      await strapi.delete(pluralName, String(id));
+    },
+  };
+}
+
+// Helper to get typed single type
+export function single<T>(singularName: string) {
+  return {
+    async find(params?: Record<string, unknown>): Promise<{ data: T }> {
+      const response = await strapi.find(singularName, params) as unknown as StrapiV4RawSingleResponse<T>;
+      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>;
+      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    },
+    async delete(): Promise<void> {
+      await strapi.delete(singularName, 1 as unknown as string);
+    },
+  };
+}
+`;
+  }
+  return `/**
+ * Strapi Client (v5)
+ * Generated by strapi2front
+ */
+
+import Strapi from 'strapi-sdk-js';
+import type { StrapiPagination } 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 pagination for fallback
+const defaultPagination: StrapiPagination = {
+  page: 1,
+  pageSize: 25,
+  pageCount: 1,
+  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>;
+}
+
+// Helper to get typed collection
+export function collection<T>(pluralName: string) {
+  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>;
+      return {
+        data: Array.isArray(response.data) ? response.data : [],
+        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>;
+      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>;
+      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>;
+      return { data: response.data };
+    },
+    async delete(documentId: string): Promise<void> {
+      await strapi.delete(pluralName, documentId);
+    },
+  };
+}
+
+// Helper to get typed single type
+export function single<T>(singularName: string) {
+  return {
+    async find(params?: Record<string, unknown>): Promise<{ data: T }> {
+      const response = await strapi.find(singularName, params) as unknown as StrapiSingleResponse<T>;
+      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>;
+      return { data: response.data };
+    },
+    async delete(): Promise<void> {
+      await strapi.delete(singularName, 1 as unknown as string);
+    },
+  };
+}
+`;
+}
+function generateLocalesFile2(locales) {
+  if (locales.length === 0) {
+    return `/**
+ * Strapi locales
+ * Generated by strapi2front
+ * Note: i18n is not enabled in Strapi
+ */
+
+export const locales = [] as const;
+export type Locale = string;
+export const defaultLocale: Locale = 'en';
+export const localeNames: Record<string, string> = {};
+
+export function isValidLocale(_code: string): _code is Locale {
+  return true;
+}
+
+export function getLocaleName(code: string): string {
+  return code;
+}
+`;
+  }
+  const localeCodes = locales.map((l) => l.code);
+  const defaultLocale = locales.find((l) => l.isDefault)?.code || locales[0]?.code || "en";
+  return `/**
+ * Strapi locales
+ * Generated by strapi2front
+ */
+
+export const locales = [${localeCodes.map((c) => `'${c}'`).join(", ")}] as const;
+
+export type Locale = typeof locales[number];
+
+export const defaultLocale: Locale = '${defaultLocale}';
+
+export const localeNames: Record<Locale, string> = {
+${locales.map((l) => `  '${l.code}': '${l.name}'`).join(",\n")}
+};
+
+export function isValidLocale(code: string): code is Locale {
+  return locales.includes(code as Locale);
+}
+
+export function getLocaleName(code: Locale): string {
+  return localeNames[code] || code;
+}
+`;
+}
+function generateCollectionTypes(collection, schema) {
+  const typeName = toPascalCase(collection.singularName);
+  const attributes = generateAttributes2(collection.attributes);
+  const imports = generateTypeImports(collection.attributes, schema, "collection");
+  return `/**
+ * ${collection.displayName}
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ */
+
+${imports}
+
+export interface ${typeName} extends StrapiBaseEntity {
+${attributes}
+}
+
+export interface ${typeName}Filters {
+  id?: number | { $eq?: number; $ne?: number; $in?: number[]; $notIn?: number[] };
+  documentId?: string | { $eq?: string; $ne?: string };
+  createdAt?: string | { $eq?: string; $gt?: string; $gte?: string; $lt?: string; $lte?: string };
+  updatedAt?: string | { $eq?: string; $gt?: string; $gte?: string; $lt?: string; $lte?: string };
+  publishedAt?: string | null | { $eq?: string; $ne?: string; $null?: boolean };
+  $and?: ${typeName}Filters[];
+  $or?: ${typeName}Filters[];
+  $not?: ${typeName}Filters;
+}
+`;
+}
+function generateSingleTypes(single, schema) {
+  const typeName = toPascalCase(single.singularName);
+  const attributes = generateAttributes2(single.attributes);
+  const imports = generateTypeImports(single.attributes, schema, "single");
+  return `/**
+ * ${single.displayName}
+ * ${single.description || ""}
+ * Generated by strapi2front
+ */
+
+${imports}
+
+export interface ${typeName} extends StrapiBaseEntity {
+${attributes}
+}
+`;
+}
+function generateComponentTypes(component, schema) {
+  const typeName = toPascalCase(component.name);
+  const attributes = generateAttributes2(component.attributes);
+  const imports = generateTypeImports(component.attributes, schema, "component");
+  return `/**
+ * ${component.displayName} component
+ * Category: ${component.category}
+ * ${component.description || ""}
+ * Generated by strapi2front
+ */
+
+${imports}
+
+export interface ${typeName} {
+  id: number;
+${attributes}
+}
+`;
+}
+function generateTypeImports(attributes, schema, context) {
+  const utilsImports = [];
+  const relationImports = /* @__PURE__ */ new Map();
+  const componentImports = /* @__PURE__ */ new Map();
+  const attributesStr = JSON.stringify(attributes);
+  if (context !== "component") {
+    utilsImports.push("StrapiBaseEntity");
+  }
+  if (attributesStr.includes('"type":"media"')) {
+    utilsImports.push("StrapiMedia");
+  }
+  if (attributesStr.includes('"type":"blocks"')) {
+    utilsImports.push("BlocksContent");
+  }
+  const relativePrefix = context === "component" ? ".." : "../..";
+  for (const attr of Object.values(attributes)) {
+    if (attr.type === "relation" && "target" in attr && attr.target) {
+      const targetName = attr.target.split(".").pop() || "";
+      if (targetName) {
+        const typeName = toPascalCase(targetName);
+        const fileName = toKebabCase(targetName);
+        const isCollection = schema.collections.some((c) => c.singularName === targetName);
+        const isSingle = schema.singles.some((s) => s.singularName === targetName);
+        if (isCollection) {
+          relationImports.set(typeName, `${relativePrefix}/collections/${fileName}/types`);
+        } else if (isSingle) {
+          relationImports.set(typeName, `${relativePrefix}/singles/${fileName}/types`);
+        }
+      }
+    }
+    if (attr.type === "component" && "component" in attr && attr.component) {
+      const componentName = attr.component.split(".").pop() || "";
+      if (componentName) {
+        const typeName = toPascalCase(componentName);
+        const fileName = toKebabCase(componentName);
+        if (context === "component") {
+          componentImports.set(typeName, `./${fileName}`);
+        } else {
+          componentImports.set(typeName, `../../components/${fileName}`);
+        }
+      }
+    }
+    if (attr.type === "dynamiczone" && "components" in attr && attr.components) {
+      for (const comp of attr.components) {
+        const componentName = comp.split(".").pop() || "";
+        if (componentName) {
+          const typeName = toPascalCase(componentName);
+          const fileName = toKebabCase(componentName);
+          if (context === "component") {
+            componentImports.set(typeName, `./${fileName}`);
+          } else {
+            componentImports.set(typeName, `../../components/${fileName}`);
+          }
+        }
+      }
+    }
+  }
+  const lines = [];
+  if (utilsImports.length > 0) {
+    const utilsPath = context === "component" ? "../shared/utils" : "../../shared/utils";
+    lines.push(`import type { ${utilsImports.join(", ")} } from '${utilsPath}';`);
+  }
+  for (const [typeName, importPath] of relationImports) {
+    lines.push(`import type { ${typeName} } from '${importPath}';`);
+  }
+  for (const [typeName, importPath] of componentImports) {
+    lines.push(`import type { ${typeName} } from '${importPath}';`);
+  }
+  return lines.join("\n");
+}
+function generateAttributes2(attributes) {
+  const lines = [];
+  for (const [name, attr] of Object.entries(attributes)) {
+    const tsType = attributeToTsType(attr);
+    const optional = attr.required ? "" : "?";
+    lines.push(`  ${name}${optional}: ${tsType};`);
+  }
+  return lines.join("\n");
+}
+function attributeToTsType(attr) {
+  switch (attr.type) {
+    case "string":
+    case "text":
+    case "richtext":
+    case "email":
+    case "password":
+    case "uid":
+      return "string";
+    case "blocks":
+      return "BlocksContent";
+    case "integer":
+    case "biginteger":
+    case "float":
+    case "decimal":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "time":
+    case "datetime":
+    case "timestamp":
+      return "string";
+    case "json":
+      return "unknown";
+    case "enumeration":
+      if ("enum" in attr && attr.enum) {
+        return attr.enum.map((v) => `'${v}'`).join(" | ");
+      }
+      return "string";
+    case "media":
+      if ("multiple" in attr && attr.multiple) {
+        return "StrapiMedia[]";
+      }
+      return "StrapiMedia | null";
+    case "relation":
+      if ("target" in attr && attr.target) {
+        const targetName = toPascalCase(attr.target.split(".").pop() || "unknown");
+        const isMany = attr.relation === "oneToMany" || attr.relation === "manyToMany";
+        return isMany ? `${targetName}[]` : `${targetName} | null`;
+      }
+      return "unknown";
+    case "component":
+      if ("component" in attr && attr.component) {
+        const componentName = toPascalCase(attr.component.split(".").pop() || "unknown");
+        if ("repeatable" in attr && attr.repeatable) {
+          return `${componentName}[]`;
+        }
+        return `${componentName} | null`;
+      }
+      return "unknown";
+    case "dynamiczone":
+      if ("components" in attr && attr.components) {
+        const types = attr.components.map((c) => toPascalCase(c.split(".").pop() || "unknown"));
+        return `(${types.join(" | ")})[]`;
+      }
+      return "unknown[]";
+    default:
+      return "unknown";
+  }
+}
+function generateCollectionService3(collection, strapiVersion) {
+  const typeName = toPascalCase(collection.singularName);
+  const serviceName = toCamelCase(collection.singularName) + "Service";
+  const endpoint = collection.pluralName;
+  const hasSlug = "slug" in collection.attributes;
+  const { localized, draftAndPublish } = collection;
+  const isV4 = strapiVersion === "v4";
+  const idParam = isV4 ? "id: number" : "documentId: string";
+  const idName = isV4 ? "id" : "documentId";
+  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 type { ${typeName}, ${typeName}Filters } from './types';`,
+    `import type { StrapiPagination } from '../../shared/utils';`
+  ];
+  if (localized) {
+    imports.push(`import type { Locale } from '../../shared/locales';`);
+  }
+  const paginationFields = `
+    /** Page number (1-indexed) - use with pageSize */
+    page?: number;
+    /** Number of items per page (default: 25) - use with page */
+    pageSize?: number;
+    /** Offset to start from (0-indexed) - use with limit */
+    start?: number;
+    /** Maximum number of items to return - use with start */
+    limit?: number;`;
+  let findManyOptionsFields = `  filters?: ${typeName}Filters;
+  pagination?: {${paginationFields}
+  };
+  sort?: string | string[];
+  populate?: string | string[] | Record<string, unknown>;`;
+  let findOneOptionsFields = `  populate?: string | string[] | Record<string, unknown>;`;
+  if (localized) {
+    findManyOptionsFields += `
+  locale?: Locale;`;
+    findOneOptionsFields += `
+  locale?: Locale;`;
+  }
+  if (draftAndPublish) {
+    findManyOptionsFields += `
+  status?: 'draft' | 'published';`;
+    findOneOptionsFields += `
+  status?: 'draft' | 'published';`;
+  }
+  let findParams = `      filters: options.filters,
+      pagination: options.pagination,
+      sort: options.sort,
+      populate: options.populate,`;
+  let findOneParams = `        populate: options.populate,`;
+  if (localized) {
+    findParams += `
+      locale: options.locale,`;
+    findOneParams += `
+        locale: options.locale,`;
+  }
+  if (draftAndPublish) {
+    findParams += `
+      status: options.status,`;
+    findOneParams += `
+        status: options.status,`;
+  }
+  return `/**
+ * ${collection.displayName} Service
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports.join("\n")}
+
+export interface FindManyOptions {
+${findManyOptionsFields}
+}
+
+export interface FindOneOptions {
+${findOneOptionsFields}
+}
+
+// Create typed collection helper
+const ${toCamelCase(collection.singularName)}Collection = collection<${typeName}>('${endpoint}');
+
+export const ${serviceName} = {
+  async findMany(options: FindManyOptions = {}): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.find({
+${findParams}
+    });
+
+    return {
+      data: response.data,
+      pagination: response.meta.pagination,
+    };
+  },
+
+  async findAll(options: Omit<FindManyOptions, 'pagination'> = {}): Promise<${typeName}[]> {
+    const allItems: ${typeName}[] = [];
+    let page = 1;
+    let hasMore = true;
+
+    while (hasMore) {
+      const { data, pagination } = await this.findMany({
+        ...options,
+        pagination: { page, pageSize: 100 },
+      });
+
+      allItems.push(...data);
+      hasMore = page < pagination.pageCount;
+      page++;
+    }
+
+    return allItems;
+  },
+
+  async findOne(${idParam}, options: FindOneOptions = {}): Promise<${typeName} | null> {
+    try {
+      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idName}, {
+${findOneParams}
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('404')) {
+        return null;
+      }
+      throw error;
+    }
+  },
+${hasSlug ? `
+  async findBySlug(slug: string, options: FindOneOptions = {}): 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," : ""}
+    });
+
+    return data[0] || null;
+  },
+` : ""}
+  async create(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.create({ data });
+    return response.data;
+  },
+
+  async update(${idParam}, data: Partial<Omit<${typeName}, ${omitFieldsUpdate}>>): Promise<${typeName}> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idName}, { data });
+    return response.data;
+  },
+
+  async delete(${idParam}): Promise<void> {
+    await ${toCamelCase(collection.singularName)}Collection.delete(${idName});
+  },
+
+  async count(filters?: ${typeName}Filters): Promise<number> {
+    const { pagination } = await this.findMany({
+      filters,
+      pagination: { pageSize: 1 },
+    });
+
+    return pagination.total;
+  },
+};
+`;
+}
+function generateSingleService3(single, strapiVersion) {
+  const typeName = toPascalCase(single.singularName);
+  const serviceName = toCamelCase(single.singularName) + "Service";
+  const endpoint = single.singularName;
+  const { localized, draftAndPublish } = single;
+  const isV4 = strapiVersion === "v4";
+  const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt'";
+  const imports = [
+    `import { single } from '../../shared/client';`,
+    `import type { ${typeName} } from './types';`
+  ];
+  if (localized) {
+    imports.push(`import type { Locale } from '../../shared/locales';`);
+  }
+  let findOptionsFields = `  populate?: string | string[] | Record<string, unknown>;`;
+  if (localized) {
+    findOptionsFields += `
+  locale?: Locale;`;
+  }
+  if (draftAndPublish) {
+    findOptionsFields += `
+  status?: 'draft' | 'published';`;
+  }
+  let findParams = `        populate: options.populate,`;
+  if (localized) {
+    findParams += `
+        locale: options.locale,`;
+  }
+  if (draftAndPublish) {
+    findParams += `
+        status: options.status,`;
+  }
+  return `/**
+ * ${single.displayName} Service (Single Type)
+ * ${single.description || ""}
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports.join("\n")}
+
+export interface FindOptions {
+${findOptionsFields}
+}
+
+// Create typed single helper
+const ${toCamelCase(single.singularName)}Single = single<${typeName}>('${endpoint}');
+
+export const ${serviceName} = {
+  async find(options: FindOptions = {}): Promise<${typeName} | null> {
+    try {
+      const response = await ${toCamelCase(single.singularName)}Single.find({
+${findParams}
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('404')) {
+        return null;
+      }
+      throw error;
+    }
+  },
+
+  async update(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+    const response = await ${toCamelCase(single.singularName)}Single.update({ data });
+    return response.data;
+  },
+
+  async delete(): Promise<void> {
+    await ${toCamelCase(single.singularName)}Single.delete();
+  },
+};
+`;
+}
+function generateCollectionActions2(collection, strapiVersion) {
+  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";
+  return `/**
+ * ${collection.displayName} Astro Actions
+ * ${collection.description || ""}
+ * Generated by strapi2front
+ * Strapi version: ${strapiVersion}
+ */
+
+import { defineAction } from 'astro:actions';
+import { z } from 'astro:schema';
+import { ${serviceName} } from './service';
+import type { ${typeName} } from './types';
+
+export const ${actionPrefix}Actions = {
+  getMany: defineAction({
+    input: z.object({
+      page: z.number().optional(),
+      pageSize: z.number().optional(),
+      sort: z.string().optional(),
+    }).optional(),
+    handler: async (input) => {
+      const { data, pagination } = await ${serviceName}.findMany({
+        pagination: input ? { page: input.page, pageSize: input.pageSize } : undefined,
+        sort: input?.sort,
+      });
+      return { data, pagination };
+    },
+  }),
+
+  getOne: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+    }),
+    handler: async (input) => {
+      const data = await ${serviceName}.findOne(input.${idParamName});
+      return { data };
+    },
+  }),
+
+  create: defineAction({
+    input: z.object({
+      data: z.record(z.unknown()),
+    }),
+    handler: async (input) => {
+      const data = await ${serviceName}.create(input.data as Partial<${typeName}>);
+      return { data };
+    },
+  }),
+
+  update: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+      data: z.record(z.unknown()),
+    }),
+    handler: async (input) => {
+      const data = await ${serviceName}.update(input.${idParamName}, input.data as Partial<${typeName}>);
+      return { data };
+    },
+  }),
 
-/**
- * Locale display names
- */
-export const localeNames: Record<Locale, string> = {
-${localeNames}
+  delete: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+    }),
+    handler: async (input) => {
+      await ${serviceName}.delete(input.${idParamName});
+      return { success: true };
+    },
+  }),
 };
-
-/**
- * Check if a string is a valid locale
- */
-export function isValidLocale(code: string): code is Locale {
-  return locales.includes(code as Locale);
-}
-
-/**
- * Get locale name by code
- */
-export function getLocaleName(code: Locale): string {
-  return localeNames[code] || code;
-}
 `;
 }
-async function generateByFeature(schema, locales, options) {
-  const { outputDir, features, blocksRendererInstalled = false, strapiVersion = "v5", apiPrefix = "/api" } = options;
-  const generatedFiles = [];
-  await ensureDir(path7.join(outputDir, "collections"));
-  await ensureDir(path7.join(outputDir, "singles"));
-  await ensureDir(path7.join(outputDir, "components"));
-  await ensureDir(path7.join(outputDir, "shared"));
-  const sharedDir = path7.join(outputDir, "shared");
-  const utilsPath = path7.join(sharedDir, "utils.ts");
-  await writeFile(utilsPath, await formatCode(generateUtilityTypes2(blocksRendererInstalled, strapiVersion)));
-  generatedFiles.push(utilsPath);
-  const clientPath = path7.join(sharedDir, "client.ts");
-  await writeFile(clientPath, await formatCode(generateClient2(strapiVersion, apiPrefix)));
-  generatedFiles.push(clientPath);
-  const localesPath = path7.join(sharedDir, "locales.ts");
-  await writeFile(localesPath, await formatCode(generateLocalesFile2(locales)));
-  generatedFiles.push(localesPath);
-  for (const collection of schema.collections) {
-    const featureDir = path7.join(outputDir, "collections", toKebabCase(collection.singularName));
-    await ensureDir(featureDir);
-    if (features.types) {
-      const typesPath = path7.join(featureDir, "types.ts");
-      await writeFile(typesPath, await formatCode(generateCollectionTypes(collection, schema)));
-      generatedFiles.push(typesPath);
-    }
-    if (features.services) {
-      const servicePath = path7.join(featureDir, "service.ts");
-      await writeFile(servicePath, await formatCode(generateCollectionService2(collection, strapiVersion)));
-      generatedFiles.push(servicePath);
-    }
-    if (features.actions) {
-      const actionsPath = path7.join(featureDir, "actions.ts");
-      await writeFile(actionsPath, await formatCode(generateCollectionActions2(collection, strapiVersion)));
-      generatedFiles.push(actionsPath);
-    }
-  }
-  for (const single of schema.singles) {
-    const featureDir = path7.join(outputDir, "singles", toKebabCase(single.singularName));
-    await ensureDir(featureDir);
-    if (features.types) {
-      const typesPath = path7.join(featureDir, "types.ts");
-      await writeFile(typesPath, await formatCode(generateSingleTypes(single, schema)));
-      generatedFiles.push(typesPath);
-    }
-    if (features.services) {
-      const servicePath = path7.join(featureDir, "service.ts");
-      await writeFile(servicePath, await formatCode(generateSingleService2(single, strapiVersion)));
-      generatedFiles.push(servicePath);
-    }
-  }
-  for (const component of schema.components) {
-    const componentPath = path7.join(outputDir, "components", `${toKebabCase(component.name)}.ts`);
-    await writeFile(componentPath, await formatCode(generateComponentTypes(component, schema)));
-    generatedFiles.push(componentPath);
-  }
-  return generatedFiles;
-}
-function generateUtilityTypes2(blocksRendererInstalled, strapiVersion) {
+function generateUtilityTypesJSDoc(blocksRendererInstalled, strapiVersion) {
   const isV4 = strapiVersion === "v4";
   const blocksContentType = isV4 ? `/**
  * Rich text content (Strapi v4)
  * Can be markdown string or custom JSON structure
- */
-export type RichTextContent = string;` : blocksRendererInstalled ? `/**
- * Blocks content type (Strapi v5 rich text)
- * Re-exported from @strapi/blocks-react-renderer
- */
-export type { BlocksContent } from '@strapi/blocks-react-renderer';` : `/**
+ * @typedef {string} RichTextContent
+ */` : blocksRendererInstalled ? `// BlocksContent - import from '@strapi/blocks-react-renderer' for full type support` : `/**
  * Blocks content type (Strapi v5 rich text)
  *
  * For full type support and rendering, install:
  * npm install @strapi/blocks-react-renderer
  *
  * Then re-run: npx strapi2front sync
- */
-export type BlocksContent = unknown[];`;
-  const baseEntity = isV4 ? `export interface StrapiBaseEntity {
-  id: number;
-  createdAt: string;
-  updatedAt: string;
-  publishedAt: string | null;
-}` : `export interface StrapiBaseEntity {
-  id: number;
-  documentId: string;
-  createdAt: string;
-  updatedAt: string;
-  publishedAt: string | null;
-}`;
-  const mediaType = isV4 ? `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;
-}` : `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;
-}`;
+ * @typedef {Array<Object>} BlocksContent
+ */`;
+  const baseEntity = isV4 ? `/**
+ * @typedef {Object} StrapiBaseEntity
+ * @property {number} id
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ * @property {string|null} publishedAt
+ */` : `/**
+ * @typedef {Object} StrapiBaseEntity
+ * @property {number} id
+ * @property {string} documentId
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ * @property {string|null} publishedAt
+ */`;
+  const mediaType = isV4 ? `/**
+ * @typedef {Object} StrapiMedia
+ * @property {number} id
+ * @property {string} name
+ * @property {string|null} alternativeText
+ * @property {string|null} caption
+ * @property {number} width
+ * @property {number} height
+ * @property {Object|null} formats
+ * @property {StrapiMediaFormat} [formats.thumbnail]
+ * @property {StrapiMediaFormat} [formats.small]
+ * @property {StrapiMediaFormat} [formats.medium]
+ * @property {StrapiMediaFormat} [formats.large]
+ * @property {string} hash
+ * @property {string} ext
+ * @property {string} mime
+ * @property {number} size
+ * @property {string} url
+ * @property {string|null} previewUrl
+ * @property {string} provider
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ */` : `/**
+ * @typedef {Object} StrapiMedia
+ * @property {number} id
+ * @property {string} documentId
+ * @property {string} name
+ * @property {string|null} alternativeText
+ * @property {string|null} caption
+ * @property {number} width
+ * @property {number} height
+ * @property {Object|null} formats
+ * @property {StrapiMediaFormat} [formats.thumbnail]
+ * @property {StrapiMediaFormat} [formats.small]
+ * @property {StrapiMediaFormat} [formats.medium]
+ * @property {StrapiMediaFormat} [formats.large]
+ * @property {string} hash
+ * @property {string} ext
+ * @property {string} mime
+ * @property {number} size
+ * @property {string} url
+ * @property {string|null} previewUrl
+ * @property {string} provider
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ */`;
   const v4RawResponseTypes = isV4 ? `
 
 /**
- * Strapi v4 raw API response (with nested attributes)
+ * Strapi v4 raw API response item (with nested attributes)
+ * @template T
+ * @typedef {Object} StrapiV4RawItem
+ * @property {number} id
+ * @property {Omit<T, 'id'>} attributes
  */
-export interface StrapiV4RawItem<T> {
-  id: number;
-  attributes: Omit<T, 'id'>;
-}
 
-export interface StrapiV4RawResponse<T> {
-  data: StrapiV4RawItem<T>;
-  meta: Record<string, unknown>;
-}
+/**
+ * Strapi v4 raw API response
+ * @template T
+ * @typedef {Object} StrapiV4RawResponse
+ * @property {StrapiV4RawItem<T>} data
+ * @property {Object} meta
+ */
 
-export interface StrapiV4RawListResponse<T> {
-  data: StrapiV4RawItem<T>[];
-  meta: {
-    pagination: StrapiPagination;
-  };
-}
+/**
+ * Strapi v4 raw list response
+ * @template T
+ * @typedef {Object} StrapiV4RawListResponse
+ * @property {StrapiV4RawItem<T>[]} data
+ * @property {Object} meta
+ * @property {StrapiPagination} meta.pagination
+ */
 
 /**
  * Flatten Strapi v4 response item
+ * @template T
+ * @param {StrapiV4RawItem<T>} item
+ * @returns {T}
  */
-export function flattenV4Response<T>(item: StrapiV4RawItem<T>): T {
-  return { id: item.id, ...item.attributes } as T;
+function flattenV4Response(item) {
+  return { id: item.id, ...item.attributes };
 }
 
 /**
  * Flatten Strapi v4 list response
+ * @template T
+ * @param {StrapiV4RawItem<T>[]} items
+ * @returns {T[]}
  */
-export function flattenV4ListResponse<T>(items: StrapiV4RawItem<T>[]): T[] {
-  return items.map(item => flattenV4Response<T>(item));
-}` : "";
-  return `/**
+function flattenV4ListResponse(items) {
+  return items.map(item => flattenV4Response(item));
+}
+
+module.exports = { flattenV4Response, flattenV4ListResponse };` : "";
+  return `// @ts-check
+/**
  * Strapi utility types
  * Generated by strapi2front
  * Strapi version: ${strapiVersion}
@@ -1673,61 +3298,67 @@ export function flattenV4ListResponse<T>(items: StrapiV4RawItem<T>[]): T[] {
 
 ${mediaType}
 
-export interface StrapiMediaFormat {
-  name: string;
-  hash: string;
-  ext: string;
-  mime: string;
-  width: number;
-  height: number;
-  size: number;
-  url: string;
-}
+/**
+ * @typedef {Object} StrapiMediaFormat
+ * @property {string} name
+ * @property {string} hash
+ * @property {string} ext
+ * @property {string} mime
+ * @property {number} width
+ * @property {number} height
+ * @property {number} size
+ * @property {string} url
+ */
 
-export interface StrapiPagination {
-  page: number;
-  pageSize: number;
-  pageCount: number;
-  total: number;
-}
+/**
+ * @typedef {Object} StrapiPagination
+ * @property {number} page
+ * @property {number} pageSize
+ * @property {number} pageCount
+ * @property {number} total
+ */
 
-export interface StrapiResponse<T> {
-  data: T;
-  meta: {
-    pagination?: StrapiPagination;
-  };
-}
+/**
+ * @template T
+ * @typedef {Object} StrapiResponse
+ * @property {T} data
+ * @property {Object} meta
+ * @property {StrapiPagination} [meta.pagination]
+ */
 
-export interface StrapiListResponse<T> {
-  data: T[];
-  meta: {
-    pagination: StrapiPagination;
-  };
-}
+/**
+ * @template T
+ * @typedef {Object} StrapiListResponse
+ * @property {T[]} data
+ * @property {Object} meta
+ * @property {StrapiPagination} meta.pagination
+ */
 
 ${baseEntity}
 ${v4RawResponseTypes}
 ${blocksContentType}
+
+module.exports = {};
 `;
 }
-function generateClient2(strapiVersion, apiPrefix = "/api") {
+function generateClientJSDoc(strapiVersion, apiPrefix = "/api") {
   const isV4 = strapiVersion === "v4";
   const normalizedPrefix = apiPrefix.startsWith("/") ? apiPrefix : "/" + apiPrefix;
   if (isV4) {
-    return `/**
+    return `// @ts-check
+/**
  * Strapi Client (v4)
  * Generated by strapi2front
  */
 
-import Strapi from 'strapi-sdk-js';
-import type { StrapiPagination } from './utils';
+const Strapi = require('strapi-sdk-js').default;
 
 // 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}';
+const strapiUrl = process.env.STRAPI_URL || 'http://localhost:1337';
+const strapiToken = process.env.STRAPI_TOKEN;
+const strapiApiPrefix = process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
 
-export const strapi = new Strapi({
+const strapi = new Strapi({
   url: strapiUrl,
   prefix: strapiApiPrefix,
   axiosOptions: {
@@ -1737,63 +3368,49 @@ export const strapi = new Strapi({
   },
 });
 
-// Default pagination for fallback
-const defaultPagination: StrapiPagination = {
+/** @type {import('./utils').StrapiPagination} */
+const defaultPagination = {
   page: 1,
   pageSize: 25,
   pageCount: 1,
   total: 0,
 };
 
-// Strapi v4 raw response types (with nested attributes)
-interface StrapiV4RawItem<T> {
-  id: number;
-  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)
+ * @template T
+ * @param {{ id: number, attributes: Omit<T, 'id'> }} item
+ * @returns {T}
  */
-function flattenItem<T>(item: StrapiV4RawItem<T>): T {
-  return { id: item.id, ...item.attributes } as T;
+function flattenItem(item) {
+  return { id: item.id, ...item.attributes };
 }
 
 /**
  * Recursively flatten nested relations in Strapi v4 response
+ * @template T
+ * @param {T} data
+ * @returns {T}
  */
-function flattenRelations<T>(data: T): T {
+function flattenRelations(data) {
   if (data === null || data === undefined) return data;
   if (Array.isArray(data)) {
-    return data.map(item => flattenRelations(item)) as unknown as T;
+    return /** @type {T} */ (data.map(item => flattenRelations(item)));
   }
   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 } }
+    /** @type {Record<string, unknown>} */
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
       if (value && typeof value === 'object' && 'data' in value) {
-        const relationData = (value as { data: unknown }).data;
+        const relationData = /** @type {{ data: unknown }} */ (value).data;
         if (relationData === null) {
           result[key] = null;
         } else if (Array.isArray(relationData)) {
-          // To-many relation
-          result[key] = relationData.map((item: StrapiV4RawItem<unknown>) =>
+          result[key] = relationData.map((item) =>
             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>));
+          result[key] = flattenRelations(flattenItem(/** @type {{ id: number, attributes: object }} */ (relationData)));
         } else {
           result[key] = flattenRelations(value);
         }
@@ -1801,76 +3418,148 @@ function flattenRelations<T>(data: T): T {
         result[key] = flattenRelations(value);
       }
     }
-    return result as T;
+    return /** @type {T} */ (result);
   }
   return data;
 }
 
-// Helper to get typed collection
-export function collection<T>(pluralName: string) {
+/**
+ * Helper to get typed collection
+ * @template T
+ * @param {string} pluralName
+ */
+function 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 flattenedData = Array.isArray(response.data)
-        ? response.data.map(item => flattenRelations(flattenItem<T>(item)))
+    /**
+     * @param {Record<string, unknown>} [params]
+     * @returns {Promise<{ data: T[], meta: { pagination: import('./utils').StrapiPagination } }>}
+     */
+    async find(params) {
+      const response = await strapi.find(pluralName, params);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T[]} */
+      const data = Array.isArray(rawData)
+        ? rawData.map(item => flattenRelations(flattenItem(item)))
         : [];
-      return {
-        data: flattenedData,
-        meta: {
-          pagination: response.meta?.pagination || defaultPagination,
-        },
+      /** @type {any} */
+      const rawMeta = response.meta;
+      /** @type {any} */
+      const rawPag = rawMeta?.pagination;
+      /** @type {import('./utils').StrapiPagination} */
+      const pagination = {
+        page: rawPag?.page ?? defaultPagination.page,
+        pageSize: rawPag?.pageSize ?? defaultPagination.pageSize,
+        pageCount: rawPag?.pageCount ?? defaultPagination.pageCount,
+        total: rawPag?.total ?? defaultPagination.total,
       };
+      return { data, meta: { pagination } };
     },
-    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>;
-      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    /**
+     * @param {number|string} id
+     * @param {Record<string, unknown>} [params]
+     * @returns {Promise<{ data: T }>}
+     */
+    async findOne(id, params) {
+      const response = await strapi.findOne(pluralName, String(id), params);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const data = flattenRelations(flattenItem(rawData));
+      return { 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>;
-      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    /**
+     * @param {{ data: Partial<T> }} data
+     * @returns {Promise<{ data: T }>}
+     */
+    async create(data) {
+      const response = await strapi.create(pluralName, data.data);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const result = flattenRelations(flattenItem(rawData));
+      return { data: result };
     },
-    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>;
-      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    /**
+     * @param {number|string} id
+     * @param {{ data: Partial<T> }} data
+     * @returns {Promise<{ data: T }>}
+     */
+    async update(id, data) {
+      const response = await strapi.update(pluralName, String(id), data.data);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const result = flattenRelations(flattenItem(rawData));
+      return { data: result };
     },
-    async delete(id: number | string): Promise<void> {
+    /**
+     * @param {number|string} id
+     * @returns {Promise<void>}
+     */
+    async delete(id) {
       await strapi.delete(pluralName, String(id));
     },
   };
 }
 
-// Helper to get typed single type
-export function single<T>(singularName: string) {
+/**
+ * Helper to get typed single type
+ * @template T
+ * @param {string} singularName
+ */
+function single(singularName) {
   return {
-    async find(params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.find(singularName, params) as unknown as StrapiV4RawSingleResponse<T>;
-      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    /**
+     * @param {Record<string, unknown>} [params]
+     * @returns {Promise<{ data: T }>}
+     */
+    async find(params) {
+      const response = await strapi.find(singularName, params);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const data = flattenRelations(flattenItem(rawData));
+      return { 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>;
-      return { data: flattenRelations(flattenItem<T>(response.data)) };
+    /**
+     * @param {{ data: Partial<T> }} data
+     * @returns {Promise<{ data: T }>}
+     */
+    async update(data) {
+      const response = await strapi.update(singularName, String(1), data.data);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const result = flattenRelations(flattenItem(rawData));
+      return { data: result };
     },
-    async delete(): Promise<void> {
-      await strapi.delete(singularName, 1 as unknown as string);
+    /**
+     * @returns {Promise<void>}
+     */
+    async delete() {
+      await strapi.delete(singularName, String(1));
     },
   };
 }
+
+module.exports = { strapi, collection, single };
 `;
   }
-  return `/**
+  return `// @ts-check
+/**
  * Strapi Client (v5)
  * Generated by strapi2front
  */
 
-import Strapi from 'strapi-sdk-js';
-import type { StrapiPagination } from './utils';
+const Strapi = require('strapi-sdk-js').default;
 
 // 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}';
+const strapiUrl = process.env.STRAPI_URL || 'http://localhost:1337';
+const strapiToken = process.env.STRAPI_TOKEN;
+const strapiApiPrefix = process.env.STRAPI_API_PREFIX || '${normalizedPrefix}';
 
-export const strapi = new Strapi({
+const strapi = new Strapi({
   url: strapiUrl,
   prefix: strapiApiPrefix,
   axiosOptions: {
@@ -1880,267 +3569,304 @@ export const strapi = new Strapi({
   },
 });
 
-// Default pagination for fallback
-const defaultPagination: StrapiPagination = {
+/** @type {import('./utils').StrapiPagination} */
+const defaultPagination = {
   page: 1,
   pageSize: 25,
   pageCount: 1,
   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>;
-}
-
-// Helper to get typed collection
-export function collection<T>(pluralName: string) {
+/**
+ * Helper to get typed collection
+ * @template T
+ * @param {string} pluralName
+ */
+function 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>;
-      return {
-        data: Array.isArray(response.data) ? response.data : [],
-        meta: {
-          pagination: response.meta?.pagination || defaultPagination,
-        },
+    /**
+     * @param {Record<string, unknown>} [params]
+     * @returns {Promise<{ data: T[], meta: { pagination: import('./utils').StrapiPagination } }>}
+     */
+    async find(params) {
+      const response = await strapi.find(pluralName, params);
+      /** @type {any} */
+      const rawMeta = response.meta;
+      /** @type {any} */
+      const rawPag = rawMeta?.pagination;
+      /** @type {import('./utils').StrapiPagination} */
+      const pagination = {
+        page: rawPag?.page ?? defaultPagination.page,
+        pageSize: rawPag?.pageSize ?? defaultPagination.pageSize,
+        pageCount: rawPag?.pageCount ?? defaultPagination.pageCount,
+        total: rawPag?.total ?? defaultPagination.total,
       };
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T[]} */
+      const data = Array.isArray(rawData) ? rawData : [];
+      return { data, meta: { pagination } };
     },
-    async findOne(documentId: string, params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.findOne(pluralName, documentId, params) as unknown as StrapiSingleResponse<T>;
-      return { data: response.data };
+    /**
+     * @param {string} documentId
+     * @param {Record<string, unknown>} [params]
+     * @returns {Promise<{ data: T }>}
+     */
+    async findOne(documentId, params) {
+      const response = await strapi.findOne(pluralName, documentId, params);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const data = rawData;
+      return { 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>;
-      return { data: response.data };
+    /**
+     * @param {{ data: Partial<T> }} data
+     * @returns {Promise<{ data: T }>}
+     */
+    async create(data) {
+      const response = await strapi.create(pluralName, data.data);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const result = rawData;
+      return { data: result };
     },
-    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>;
-      return { data: response.data };
+    /**
+     * @param {string} documentId
+     * @param {{ data: Partial<T> }} data
+     * @returns {Promise<{ data: T }>}
+     */
+    async update(documentId, data) {
+      const response = await strapi.update(pluralName, documentId, data.data);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const result = rawData;
+      return { data: result };
     },
-    async delete(documentId: string): Promise<void> {
+    /**
+     * @param {string} documentId
+     * @returns {Promise<void>}
+     */
+    async delete(documentId) {
       await strapi.delete(pluralName, documentId);
     },
   };
 }
 
-// Helper to get typed single type
-export function single<T>(singularName: string) {
+/**
+ * Helper to get typed single type
+ * @template T
+ * @param {string} singularName
+ */
+function single(singularName) {
   return {
-    async find(params?: Record<string, unknown>): Promise<{ data: T }> {
-      const response = await strapi.find(singularName, params) as unknown as StrapiSingleResponse<T>;
-      return { data: response.data };
+    /**
+     * @param {Record<string, unknown>} [params]
+     * @returns {Promise<{ data: T }>}
+     */
+    async find(params) {
+      const response = await strapi.find(singularName, params);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const data = rawData;
+      return { 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>;
-      return { data: response.data };
+    /**
+     * @param {{ data: Partial<T> }} data
+     * @returns {Promise<{ data: T }>}
+     */
+    async update(data) {
+      const response = await strapi.update(singularName, String(1), data.data);
+      /** @type {any} */
+      const rawData = response.data;
+      /** @type {T} */
+      const result = rawData;
+      return { data: result };
     },
-    async delete(): Promise<void> {
-      await strapi.delete(singularName, 1 as unknown as string);
+    /**
+     * @returns {Promise<void>}
+     */
+    async delete() {
+      await strapi.delete(singularName, String(1));
     },
   };
 }
+
+module.exports = { strapi, collection, single };
 `;
 }
-function generateLocalesFile2(locales) {
+function generateLocalesFileJSDoc(locales) {
   if (locales.length === 0) {
-    return `/**
+    return `// @ts-check
+/**
  * Strapi locales
  * Generated by strapi2front
  * Note: i18n is not enabled in Strapi
  */
 
-export const locales = [] as const;
-export type Locale = string;
-export const defaultLocale: Locale = 'en';
-export const localeNames: Record<string, string> = {};
+/** @type {readonly string[]} */
+const locales = [];
 
-export function isValidLocale(_code: string): _code is Locale {
+/** @typedef {string} Locale */
+
+/** @type {string} */
+const defaultLocale = 'en';
+
+/** @type {Record<string, string>} */
+const localeNames = {};
+
+/**
+ * @param {string} _code
+ * @returns {boolean}
+ */
+function isValidLocale(_code) {
   return true;
 }
 
-export function getLocaleName(code: string): string {
+/**
+ * @param {string} code
+ * @returns {string}
+ */
+function getLocaleName(code) {
   return code;
 }
+
+module.exports = { locales, defaultLocale, localeNames, isValidLocale, getLocaleName };
 `;
   }
   const localeCodes = locales.map((l) => l.code);
   const defaultLocale = locales.find((l) => l.isDefault)?.code || locales[0]?.code || "en";
-  return `/**
+  return `// @ts-check
+/**
  * Strapi locales
  * Generated by strapi2front
  */
 
-export const locales = [${localeCodes.map((c) => `'${c}'`).join(", ")}] as const;
+/** @type {readonly [${localeCodes.map((c) => `'${c}'`).join(", ")}]} */
+const locales = [${localeCodes.map((c) => `'${c}'`).join(", ")}];
 
-export type Locale = typeof locales[number];
+/** @typedef {${localeCodes.map((c) => `'${c}'`).join(" | ")}} Locale */
 
-export const defaultLocale: Locale = '${defaultLocale}';
+/** @type {Locale} */
+const defaultLocale = '${defaultLocale}';
 
-export const localeNames: Record<Locale, string> = {
+/** @type {Record<Locale, string>} */
+const localeNames = {
 ${locales.map((l) => `  '${l.code}': '${l.name}'`).join(",\n")}
 };
 
-export function isValidLocale(code: string): code is Locale {
-  return locales.includes(code as Locale);
+/**
+ * @param {string} code
+ * @returns {boolean}
+ */
+function isValidLocale(code) {
+  /** @type {readonly string[]} */
+  const localeList = locales;
+  return localeList.includes(code);
 }
 
-export function getLocaleName(code: Locale): string {
+/**
+ * @param {Locale} code
+ * @returns {string}
+ */
+function getLocaleName(code) {
   return localeNames[code] || code;
 }
+
+module.exports = { locales, defaultLocale, localeNames, isValidLocale, getLocaleName };
 `;
 }
-function generateCollectionTypes(collection, schema) {
+function generateCollectionTypesJSDoc(collection, schema) {
   const typeName = toPascalCase(collection.singularName);
-  const attributes = generateAttributes2(collection.attributes);
-  const imports = generateTypeImports(collection.attributes, schema, "collection");
-  return `/**
+  const attributes = generateJSDocAttributes(collection.attributes, schema, "collection");
+  return `// @ts-check
+/**
  * ${collection.displayName}
  * ${collection.description || ""}
  * Generated by strapi2front
  */
 
-${imports}
+/**
+ * @typedef {import('../../shared/utils').StrapiBaseEntity & ${typeName}Attributes} ${typeName}
+ */
 
-export interface ${typeName} extends StrapiBaseEntity {
+/**
+ * @typedef {Object} ${typeName}Attributes
 ${attributes}
-}
+ */
 
-export interface ${typeName}Filters {
-  id?: number | { $eq?: number; $ne?: number; $in?: number[]; $notIn?: number[] };
-  documentId?: string | { $eq?: string; $ne?: string };
-  createdAt?: string | { $eq?: string; $gt?: string; $gte?: string; $lt?: string; $lte?: string };
-  updatedAt?: string | { $eq?: string; $gt?: string; $gte?: string; $lt?: string; $lte?: string };
-  publishedAt?: string | null | { $eq?: string; $ne?: string; $null?: boolean };
-  $and?: ${typeName}Filters[];
-  $or?: ${typeName}Filters[];
-  $not?: ${typeName}Filters;
-}
+/**
+ * @typedef {Object} ${typeName}Filters
+ * @property {number|{$eq?: number, $ne?: number, $in?: number[], $notIn?: number[]}} [id]
+ * @property {string|{$eq?: string, $ne?: string}} [documentId]
+ * @property {string|{$eq?: string, $gt?: string, $gte?: string, $lt?: string, $lte?: string}} [createdAt]
+ * @property {string|{$eq?: string, $gt?: string, $gte?: string, $lt?: string, $lte?: string}} [updatedAt]
+ * @property {string|null|{$eq?: string, $ne?: string, $null?: boolean}} [publishedAt]
+ * @property {${typeName}Filters[]} [$and]
+ * @property {${typeName}Filters[]} [$or]
+ * @property {${typeName}Filters} [$not]
+ */
+
+module.exports = {};
 `;
 }
-function generateSingleTypes(single, schema) {
+function generateSingleTypesJSDoc(single, schema) {
   const typeName = toPascalCase(single.singularName);
-  const attributes = generateAttributes2(single.attributes);
-  const imports = generateTypeImports(single.attributes, schema, "single");
-  return `/**
+  const attributes = generateJSDocAttributes(single.attributes, schema, "single");
+  return `// @ts-check
+/**
  * ${single.displayName}
  * ${single.description || ""}
  * Generated by strapi2front
  */
 
-${imports}
+/**
+ * @typedef {import('../../shared/utils').StrapiBaseEntity & ${typeName}Attributes} ${typeName}
+ */
 
-export interface ${typeName} extends StrapiBaseEntity {
+/**
+ * @typedef {Object} ${typeName}Attributes
 ${attributes}
-}
+ */
+
+module.exports = {};
 `;
 }
-function generateComponentTypes(component, schema) {
+function generateComponentTypesJSDoc(component, schema) {
   const typeName = toPascalCase(component.name);
-  const attributes = generateAttributes2(component.attributes);
-  const imports = generateTypeImports(component.attributes, schema, "component");
-  return `/**
+  const attributes = generateJSDocAttributes(component.attributes, schema, "component");
+  return `// @ts-check
+/**
  * ${component.displayName} component
  * Category: ${component.category}
  * ${component.description || ""}
  * Generated by strapi2front
  */
 
-${imports}
-
-export interface ${typeName} {
-  id: number;
+/**
+ * @typedef {Object} ${typeName}
+ * @property {number} id
 ${attributes}
-}
+ */
+
+module.exports = {};
 `;
 }
-function generateTypeImports(attributes, schema, context) {
-  const utilsImports = [];
-  const relationImports = /* @__PURE__ */ new Map();
-  const componentImports = /* @__PURE__ */ new Map();
-  const attributesStr = JSON.stringify(attributes);
-  if (context !== "component") {
-    utilsImports.push("StrapiBaseEntity");
-  }
-  if (attributesStr.includes('"type":"media"')) {
-    utilsImports.push("StrapiMedia");
-  }
-  if (attributesStr.includes('"type":"blocks"')) {
-    utilsImports.push("BlocksContent");
-  }
-  const relativePrefix = context === "component" ? ".." : "../..";
-  for (const attr of Object.values(attributes)) {
-    if (attr.type === "relation" && "target" in attr && attr.target) {
-      const targetName = attr.target.split(".").pop() || "";
-      if (targetName) {
-        const typeName = toPascalCase(targetName);
-        const fileName = toKebabCase(targetName);
-        const isCollection = schema.collections.some((c) => c.singularName === targetName);
-        const isSingle = schema.singles.some((s) => s.singularName === targetName);
-        if (isCollection) {
-          relationImports.set(typeName, `${relativePrefix}/collections/${fileName}/types`);
-        } else if (isSingle) {
-          relationImports.set(typeName, `${relativePrefix}/singles/${fileName}/types`);
-        }
-      }
-    }
-    if (attr.type === "component" && "component" in attr && attr.component) {
-      const componentName = attr.component.split(".").pop() || "";
-      if (componentName) {
-        const typeName = toPascalCase(componentName);
-        const fileName = toKebabCase(componentName);
-        if (context === "component") {
-          componentImports.set(typeName, `./${fileName}`);
-        } else {
-          componentImports.set(typeName, `../../components/${fileName}`);
-        }
-      }
-    }
-    if (attr.type === "dynamiczone" && "components" in attr && attr.components) {
-      for (const comp of attr.components) {
-        const componentName = comp.split(".").pop() || "";
-        if (componentName) {
-          const typeName = toPascalCase(componentName);
-          const fileName = toKebabCase(componentName);
-          if (context === "component") {
-            componentImports.set(typeName, `./${fileName}`);
-          } else {
-            componentImports.set(typeName, `../../components/${fileName}`);
-          }
-        }
-      }
-    }
-  }
-  const lines = [];
-  if (utilsImports.length > 0) {
-    const utilsPath = context === "component" ? "../shared/utils" : "../../shared/utils";
-    lines.push(`import type { ${utilsImports.join(", ")} } from '${utilsPath}';`);
-  }
-  for (const [typeName, importPath] of relationImports) {
-    lines.push(`import type { ${typeName} } from '${importPath}';`);
-  }
-  for (const [typeName, importPath] of componentImports) {
-    lines.push(`import type { ${typeName} } from '${importPath}';`);
-  }
-  return lines.join("\n");
-}
-function generateAttributes2(attributes) {
+function generateJSDocAttributes(attributes, schema, context) {
   const lines = [];
+  const relativePrefix = context === "component" ? ".." : "../..";
   for (const [name, attr] of Object.entries(attributes)) {
-    const tsType = attributeToTsType2(attr);
-    const optional = attr.required ? "" : "?";
-    lines.push(`  ${name}${optional}: ${tsType};`);
+    const jsType = attributeToJSDocType(attr, schema, relativePrefix);
+    const optional = attr.required ? "" : "[";
+    const optionalEnd = attr.required ? "" : "]";
+    lines.push(` * @property {${jsType}} ${optional}${name}${optionalEnd}`);
   }
   return lines.join("\n");
 }
-function attributeToTsType2(attr) {
+function attributeToJSDocType(attr, schema, relativePrefix) {
   switch (attr.type) {
     case "string":
     case "text":
@@ -2150,7 +3876,7 @@ function attributeToTsType2(attr) {
     case "uid":
       return "string";
     case "blocks":
-      return "BlocksContent";
+      return "Array<Object>";
     case "integer":
     case "biginteger":
     case "float":
@@ -2164,130 +3890,116 @@ function attributeToTsType2(attr) {
     case "timestamp":
       return "string";
     case "json":
-      return "unknown";
+      return "Object";
     case "enumeration":
       if ("enum" in attr && attr.enum) {
-        return attr.enum.map((v) => `'${v}'`).join(" | ");
+        return attr.enum.map((v) => `'${v}'`).join("|");
       }
       return "string";
     case "media":
       if ("multiple" in attr && attr.multiple) {
-        return "StrapiMedia[]";
+        return `import("${relativePrefix}/shared/utils").StrapiMedia[]`;
       }
-      return "StrapiMedia | null";
+      return `import("${relativePrefix}/shared/utils").StrapiMedia|null`;
     case "relation":
       if ("target" in attr && attr.target) {
-        const targetName = toPascalCase(attr.target.split(".").pop() || "unknown");
+        const targetName = attr.target.split(".").pop() || "unknown";
+        const typeName = toPascalCase(targetName);
+        const fileName = toKebabCase(targetName);
         const isMany = attr.relation === "oneToMany" || attr.relation === "manyToMany";
-        return isMany ? `${targetName}[]` : `${targetName} | null`;
+        const isCollection = schema.collections.some((c) => c.singularName === targetName);
+        const isSingle = schema.singles.some((s) => s.singularName === targetName);
+        let importPath;
+        if (isCollection) {
+          importPath = `${relativePrefix}/collections/${fileName}/types`;
+        } else if (isSingle) {
+          importPath = `${relativePrefix}/singles/${fileName}/types`;
+        } else {
+          importPath = `${relativePrefix}/collections/${fileName}/types`;
+        }
+        const importType = `import("${importPath}").${typeName}`;
+        return isMany ? `${importType}[]` : `${importType}|null`;
       }
-      return "unknown";
+      return "Object";
     case "component":
       if ("component" in attr && attr.component) {
-        const componentName = toPascalCase(attr.component.split(".").pop() || "unknown");
+        const componentName = attr.component.split(".").pop() || "unknown";
+        const typeName = toPascalCase(componentName);
+        const fileName = toKebabCase(componentName);
+        const importPath = `${relativePrefix}/components/${fileName}`;
+        const importType = `import("${importPath}").${typeName}`;
         if ("repeatable" in attr && attr.repeatable) {
-          return `${componentName}[]`;
+          return `${importType}[]`;
         }
-        return `${componentName} | null`;
+        return `${importType}|null`;
       }
-      return "unknown";
+      return "Object";
     case "dynamiczone":
       if ("components" in attr && attr.components) {
-        const types = attr.components.map((c) => toPascalCase(c.split(".").pop() || "unknown"));
-        return `(${types.join(" | ")})[]`;
+        const types = attr.components.map((comp) => {
+          const componentName = comp.split(".").pop() || "unknown";
+          const typeName = toPascalCase(componentName);
+          const fileName = toKebabCase(componentName);
+          const importPath = `${relativePrefix}/components/${fileName}`;
+          return `import("${importPath}").${typeName}`;
+        });
+        return `(${types.join("|")})[]`;
       }
-      return "unknown[]";
+      return "Object[]";
     default:
-      return "unknown";
+      return "Object";
   }
 }
-function generateCollectionService2(collection, strapiVersion) {
+function generateCollectionServiceJSDoc(collection, strapiVersion) {
   const typeName = toPascalCase(collection.singularName);
   const serviceName = toCamelCase(collection.singularName) + "Service";
   const endpoint = collection.pluralName;
   const hasSlug = "slug" in collection.attributes;
   const { localized, draftAndPublish } = collection;
   const isV4 = strapiVersion === "v4";
-  const idParam = isV4 ? "id: number" : "documentId: string";
-  const idName = isV4 ? "id" : "documentId";
-  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 type { ${typeName}, ${typeName}Filters } from './types';`,
-    `import type { StrapiPagination } from '../../shared/utils';`
-  ];
-  if (localized) {
-    imports.push(`import type { Locale } from '../../shared/locales';`);
-  }
-  const paginationFields = `
-    /** Page number (1-indexed) - use with pageSize */
-    page?: number;
-    /** Number of items per page (default: 25) - use with page */
-    pageSize?: number;
-    /** Offset to start from (0-indexed) - use with limit */
-    start?: number;
-    /** Maximum number of items to return - use with start */
-    limit?: number;`;
-  let findManyOptionsFields = `  filters?: ${typeName}Filters;
-  pagination?: {${paginationFields}
-  };
-  sort?: string | string[];
-  populate?: string | string[] | Record<string, unknown>;`;
-  let findOneOptionsFields = `  populate?: string | string[] | Record<string, unknown>;`;
-  if (localized) {
-    findManyOptionsFields += `
-  locale?: Locale;`;
-    findOneOptionsFields += `
-  locale?: Locale;`;
-  }
-  if (draftAndPublish) {
-    findManyOptionsFields += `
-  status?: 'draft' | 'published';`;
-    findOneOptionsFields += `
-  status?: 'draft' | 'published';`;
-  }
-  let findParams = `      filters: options.filters,
-      pagination: options.pagination,
-      sort: options.sort,
-      populate: options.populate,`;
-  let findOneParams = `        populate: options.populate,`;
-  if (localized) {
-    findParams += `
-      locale: options.locale,`;
-    findOneParams += `
-        locale: options.locale,`;
-  }
-  if (draftAndPublish) {
-    findParams += `
-      status: options.status,`;
-    findOneParams += `
-        status: options.status,`;
-  }
-  return `/**
+  const idParam = isV4 ? "id" : "documentId";
+  const idType = isV4 ? "number" : "string";
+  return `// @ts-check
+/**
  * ${collection.displayName} Service
  * ${collection.description || ""}
  * Generated by strapi2front
  * Strapi version: ${strapiVersion}
  */
 
-${imports.join("\n")}
+const { collection } = require('../../shared/client');
 
-export interface FindManyOptions {
-${findManyOptionsFields}
-}
+/**
+ * @typedef {Object} FindManyOptions
+ * @property {import('./types').${typeName}Filters} [filters]
+ * @property {Object} [pagination]
+ * @property {number} [pagination.page]
+ * @property {number} [pagination.pageSize]
+ * @property {number} [pagination.start]
+ * @property {number} [pagination.limit]
+ * @property {string|string[]} [sort]
+ * @property {string|string[]|Record<string, unknown>} [populate]${localized ? "\n * @property {string} [locale]" : ""}${draftAndPublish ? "\n * @property {'draft'|'published'} [status]" : ""}
+ */
 
-export interface FindOneOptions {
-${findOneOptionsFields}
-}
+/**
+ * @typedef {Object} FindOneOptions
+ * @property {string|string[]|Record<string, unknown>} [populate]${localized ? "\n * @property {string} [locale]" : ""}${draftAndPublish ? "\n * @property {'draft'|'published'} [status]" : ""}
+ */
 
-// Create typed collection helper
-const ${toCamelCase(collection.singularName)}Collection = collection<${typeName}>('${endpoint}');
+/** @type {ReturnType<typeof collection<import('./types').${typeName}>>} */
+const ${toCamelCase(collection.singularName)}Collection = collection('${endpoint}');
 
-export const ${serviceName} = {
-  async findMany(options: FindManyOptions = {}): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
+const ${serviceName} = {
+  /**
+   * @param {FindManyOptions} [options]
+   * @returns {Promise<{ data: import('./types').${typeName}[], pagination: import('../../shared/utils').StrapiPagination }>}
+   */
+  async findMany(options = {}) {
     const response = await ${toCamelCase(collection.singularName)}Collection.find({
-${findParams}
+      filters: options.filters,
+      pagination: options.pagination,
+      sort: options.sort,
+      populate: options.populate,${localized ? "\n      locale: options.locale," : ""}${draftAndPublish ? "\n      status: options.status," : ""}
     });
 
     return {
@@ -2296,8 +4008,13 @@ ${findParams}
     };
   },
 
-  async findAll(options: Omit<FindManyOptions, 'pagination'> = {}): Promise<${typeName}[]> {
-    const allItems: ${typeName}[] = [];
+  /**
+   * @param {Omit<FindManyOptions, 'pagination'>} [options]
+   * @returns {Promise<import('./types').${typeName}[]>}
+   */
+  async findAll(options = {}) {
+    /** @type {import('./types').${typeName}[]} */
+    const allItems = [];
     let page = 1;
     let hasMore = true;
 
@@ -2315,10 +4032,15 @@ ${findParams}
     return allItems;
   },
 
-  async findOne(${idParam}, options: FindOneOptions = {}): Promise<${typeName} | null> {
+  /**
+   * @param {${idType}} ${idParam}
+   * @param {FindOneOptions} [options]
+   * @returns {Promise<import('./types').${typeName}|null>}
+   */
+  async findOne(${idParam}, options = {}) {
     try {
-      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idName}, {
-${findOneParams}
+      const response = await ${toCamelCase(collection.singularName)}Collection.findOne(${idParam}, {
+        populate: options.populate,${localized ? "\n        locale: options.locale," : ""}${draftAndPublish ? "\n        status: options.status," : ""}
       });
 
       return response.data;
@@ -2330,9 +4052,14 @@ ${findOneParams}
     }
   },
 ${hasSlug ? `
-  async findBySlug(slug: string, options: FindOneOptions = {}): Promise<${typeName} | null> {
+  /**
+   * @param {string} slug
+   * @param {FindOneOptions} [options]
+   * @returns {Promise<import('./types').${typeName}|null>}
+   */
+  async findBySlug(slug, options = {}) {
     const { data } = await this.findMany({
-      filters: { slug: { $eq: slug } } as ${typeName}Filters,
+      filters: /** @type {import('./types').${typeName}Filters} */ ({ slug: { $eq: slug } }),
       pagination: { pageSize: 1 },
       populate: options.populate,${localized ? "\n      locale: options.locale," : ""}${draftAndPublish ? "\n      status: options.status," : ""}
     });
@@ -2340,21 +4067,38 @@ ${hasSlug ? `
     return data[0] || null;
   },
 ` : ""}
-  async create(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+  /**
+   * @param {Partial<import('./types').${typeName}>} data
+   * @returns {Promise<import('./types').${typeName}>}
+   */
+  async create(data) {
     const response = await ${toCamelCase(collection.singularName)}Collection.create({ data });
     return response.data;
   },
 
-  async update(${idParam}, data: Partial<Omit<${typeName}, ${omitFieldsUpdate}>>): Promise<${typeName}> {
-    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idName}, { data });
+  /**
+   * @param {${idType}} ${idParam}
+   * @param {Partial<import('./types').${typeName}>} data
+   * @returns {Promise<import('./types').${typeName}>}
+   */
+  async update(${idParam}, data) {
+    const response = await ${toCamelCase(collection.singularName)}Collection.update(${idParam}, { data });
     return response.data;
   },
 
-  async delete(${idParam}): Promise<void> {
-    await ${toCamelCase(collection.singularName)}Collection.delete(${idName});
+  /**
+   * @param {${idType}} ${idParam}
+   * @returns {Promise<void>}
+   */
+  async delete(${idParam}) {
+    await ${toCamelCase(collection.singularName)}Collection.delete(${idParam});
   },
 
-  async count(filters?: ${typeName}Filters): Promise<number> {
+  /**
+   * @param {import('./types').${typeName}Filters} [filters]
+   * @returns {Promise<number>}
+   */
+  async count(filters) {
     const { pagination } = await this.findMany({
       filters,
       pagination: { pageSize: 1 },
@@ -2363,61 +4107,42 @@ ${hasSlug ? `
     return pagination.total;
   },
 };
+
+module.exports = { ${serviceName} };
 `;
 }
-function generateSingleService2(single, strapiVersion) {
+function generateSingleServiceJSDoc(single, strapiVersion) {
   const typeName = toPascalCase(single.singularName);
   const serviceName = toCamelCase(single.singularName) + "Service";
   const endpoint = single.singularName;
   const { localized, draftAndPublish } = single;
-  const isV4 = strapiVersion === "v4";
-  const omitFields = isV4 ? "'id' | 'createdAt' | 'updatedAt'" : "'id' | 'documentId' | 'createdAt' | 'updatedAt'";
-  const imports = [
-    `import { single } from '../../shared/client';`,
-    `import type { ${typeName} } from './types';`
-  ];
-  if (localized) {
-    imports.push(`import type { Locale } from '../../shared/locales';`);
-  }
-  let findOptionsFields = `  populate?: string | string[] | Record<string, unknown>;`;
-  if (localized) {
-    findOptionsFields += `
-  locale?: Locale;`;
-  }
-  if (draftAndPublish) {
-    findOptionsFields += `
-  status?: 'draft' | 'published';`;
-  }
-  let findParams = `        populate: options.populate,`;
-  if (localized) {
-    findParams += `
-        locale: options.locale,`;
-  }
-  if (draftAndPublish) {
-    findParams += `
-        status: options.status,`;
-  }
-  return `/**
+  return `// @ts-check
+/**
  * ${single.displayName} Service (Single Type)
  * ${single.description || ""}
  * Generated by strapi2front
  * Strapi version: ${strapiVersion}
  */
 
-${imports.join("\n")}
+const { single } = require('../../shared/client');
 
-export interface FindOptions {
-${findOptionsFields}
-}
+/**
+ * @typedef {Object} FindOptions
+ * @property {string|string[]|Record<string, unknown>} [populate]${localized ? "\n * @property {string} [locale]" : ""}${draftAndPublish ? "\n * @property {'draft'|'published'} [status]" : ""}
+ */
 
-// Create typed single helper
-const ${toCamelCase(single.singularName)}Single = single<${typeName}>('${endpoint}');
+/** @type {ReturnType<typeof single<import('./types').${typeName}>>} */
+const ${toCamelCase(single.singularName)}Single = single('${endpoint}');
 
-export const ${serviceName} = {
-  async find(options: FindOptions = {}): Promise<${typeName} | null> {
+const ${serviceName} = {
+  /**
+   * @param {FindOptions} [options]
+   * @returns {Promise<import('./types').${typeName}|null>}
+   */
+  async find(options = {}) {
     try {
       const response = await ${toCamelCase(single.singularName)}Single.find({
-${findParams}
+        populate: options.populate,${localized ? "\n        locale: options.locale," : ""}${draftAndPublish ? "\n        status: options.status," : ""}
       });
 
       return response.data;
@@ -2429,96 +4154,60 @@ ${findParams}
     }
   },
 
-  async update(data: Partial<Omit<${typeName}, ${omitFields}>>): Promise<${typeName}> {
+  /**
+   * @param {Partial<import('./types').${typeName}>} data
+   * @returns {Promise<import('./types').${typeName}>}
+   */
+  async update(data) {
     const response = await ${toCamelCase(single.singularName)}Single.update({ data });
     return response.data;
   },
 
-  async delete(): Promise<void> {
+  /**
+   * @returns {Promise<void>}
+   */
+  async delete() {
     await ${toCamelCase(single.singularName)}Single.delete();
   },
 };
+
+module.exports = { ${serviceName} };
 `;
 }
-function generateCollectionActions2(collection, strapiVersion) {
-  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";
-  return `/**
- * ${collection.displayName} Astro Actions
- * ${collection.description || ""}
- * Generated by strapi2front
- * Strapi version: ${strapiVersion}
- */
-
-import { defineAction } from 'astro:actions';
-import { z } from 'astro:schema';
-import { ${serviceName} } from './service';
-import type { ${typeName} } from './types';
-
-export const ${actionPrefix}Actions = {
-  getMany: defineAction({
-    input: z.object({
-      page: z.number().optional(),
-      pageSize: z.number().optional(),
-      sort: z.string().optional(),
-    }).optional(),
-    handler: async (input) => {
-      const { data, pagination } = await ${serviceName}.findMany({
-        pagination: input ? { page: input.page, pageSize: input.pageSize } : undefined,
-        sort: input?.sort,
-      });
-      return { data, pagination };
-    },
-  }),
-
-  getOne: defineAction({
-    input: z.object({
-      ${idParamName}: ${idInputSchema},
-    }),
-    handler: async (input) => {
-      const data = await ${serviceName}.findOne(input.${idParamName});
-      return { data };
-    },
-  }),
 
-  create: defineAction({
-    input: z.object({
-      data: z.record(z.unknown()),
-    }),
-    handler: async (input) => {
-      const data = await ${serviceName}.create(input.data as Partial<${typeName}>);
-      return { data };
-    },
-  }),
+// src/frameworks/nextjs/actions.ts
+async function generateNextJsActions(_schema, _options) {
+  throw new Error(
+    "Next.js Server Actions generator is not yet implemented. Coming soon! For now, you can use the generated services directly."
+  );
+}
+function isNextJsActionsSupported(nextVersion) {
+  if (!nextVersion) return false;
+  const match = nextVersion.replace(/^[\^~]/, "").match(/^(\d+)/);
+  const majorVersion = match ? parseInt(match[1], 10) : null;
+  return majorVersion !== null && majorVersion >= 14;
+}
 
-  update: defineAction({
-    input: z.object({
-      ${idParamName}: ${idInputSchema},
-      data: z.record(z.unknown()),
-    }),
-    handler: async (input) => {
-      const data = await ${serviceName}.update(input.${idParamName}, input.data as Partial<${typeName}>);
-      return { data };
-    },
-  }),
+// src/frameworks/nuxt/server-routes.ts
+async function generateNuxtServerRoutes(_schema, _options) {
+  throw new Error(
+    "Nuxt Server Routes generator is not yet implemented. Coming soon! For now, you can use the generated services directly."
+  );
+}
+function isNuxtServerRoutesSupported(nuxtVersion) {
+  if (!nuxtVersion) return false;
+  const match = nuxtVersion.replace(/^[\^~]/, "").match(/^(\d+)/);
+  const majorVersion = match ? parseInt(match[1], 10) : null;
+  return majorVersion !== null && majorVersion >= 3;
+}
 
-  delete: defineAction({
-    input: z.object({
-      ${idParamName}: ${idInputSchema},
-    }),
-    handler: async (input) => {
-      await ${serviceName}.delete(input.${idParamName});
-      return { success: true };
-    },
-  }),
+// src/frameworks/index.ts
+var frameworkSupport = {
+  astro: { status: "stable", minVersion: "4.0.0" },
+  nextjs: { status: "coming-soon", minVersion: "14.0.0" },
+  nuxt: { status: "coming-soon", minVersion: "3.0.0" }
 };
-`;
-}
 
-export { deleteFile, ensureDir, fileExists, formatCode, formatJson, generateActions, generateByFeature, generateClient, generateLocales, generateServices, generateTypes, 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, isAstroActionsSupported, isNextJsActionsSupported, isNuxtServerRoutesSupported, listFiles, pluralize, readFile, toCamelCase, toKebabCase, toPascalCase, writeFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map