@strapi2front/generators 0.1.0

package/dist/index.js

@@ -0,0 +1,2512 @@
+import path7 from 'path';
+import * as prettier from 'prettier';
+import fs from 'fs/promises';
+
+// src/types/generator.ts
+async function formatCode(code) {
+  try {
+    return await prettier.format(code, {
+      parser: "typescript",
+      semi: true,
+      singleQuote: true,
+      trailingComma: "es5",
+      printWidth: 100,
+      tabWidth: 2,
+      useTabs: false
+    });
+  } catch {
+    return code;
+  }
+}
+async function formatJson(code) {
+  try {
+    return await prettier.format(code, {
+      parser: "json",
+      tabWidth: 2
+    });
+  } catch {
+    return code;
+  }
+}
+async function ensureDir(dirPath) {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function writeFile(filePath, content) {
+  const dir = path7.dirname(filePath);
+  await ensureDir(dir);
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readFile(filePath) {
+  return await fs.readFile(filePath, "utf-8");
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function deleteFile(filePath) {
+  try {
+    await fs.unlink(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+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));
+    if (extension) {
+      files = files.filter((file) => file.endsWith(extension));
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+
+// src/utils/naming.ts
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function pluralize(word) {
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
+  }
+  if (word.endsWith("y") && !["a", "e", "i", "o", "u"].includes(word.charAt(word.length - 2))) {
+    return word.slice(0, -1) + "ies";
+  }
+  return word + "s";
+}
+
+// src/types/generator.ts
+async function generateTypes(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");
+  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 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 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 content = generateComponentType(component);
+    await writeFile(filePath, await formatCode(content));
+    generatedFiles.push(filePath);
+  }
+  return generatedFiles;
+}
+function generateUtilityTypes(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 strapi-integrate sync
+ */
+export type BlocksContent = unknown[];`;
+  const baseEntity = isV4 ? `/**
+ * Base entity fields (Strapi v4)
+ */
+export interface StrapiBaseEntity {
+  id: number;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string | null;
+}` : `/**
+ * Base entity fields (Strapi v5)
+ */
+export interface StrapiBaseEntity {
+  id: number;
+  documentId: string;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string | null;
+}`;
+  const mediaType = isV4 ? `/**
+ * Strapi media object (v4)
+ */
+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;
+}` : `/**
+ * Strapi media object (v5)
+ */
+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 rawResponseTypes = 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 strapi-integrate
+ * Strapi version: ${strapiVersion}
+ */
+
+${mediaType}
+
+export interface StrapiMediaFormat {
+  name: string;
+  hash: string;
+  ext: string;
+  mime: string;
+  width: number;
+  height: number;
+  size: number;
+  url: string;
+}
+
+/**
+ * Strapi pagination
+ */
+export interface StrapiPagination {
+  page: number;
+  pageSize: number;
+  pageCount: number;
+  total: number;
+}
+
+/**
+ * Strapi response wrapper
+ */
+export interface StrapiResponse<T> {
+  data: T;
+  meta: {
+    pagination?: StrapiPagination;
+  };
+}
+
+/**
+ * Strapi list response
+ */
+export interface StrapiListResponse<T> {
+  data: T[];
+  meta: {
+    pagination: StrapiPagination;
+  };
+}
+
+${baseEntity}
+${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) {
+    const typeName = toPascalCase(relation);
+    const fileName = toKebabCase(relation);
+    imports.push(`import type { ${typeName} } from './${fileName}';`);
+  }
+  for (const component of components) {
+    const typeName = toPascalCase(component);
+    const fileName = toKebabCase(component);
+    imports.push(`import type { ${typeName} } from '../components/${fileName}';`);
+  }
+  return imports.join("\n");
+}
+function generateCollectionType(collection, components) {
+  const typeName = toPascalCase(collection.singularName);
+  const attributes = generateAttributes(collection.attributes);
+  const { relations, components: componentDeps } = extractDependencies(collection.attributes, typeName);
+  const dependencyImports = generateDependencyImports(relations, componentDeps);
+  const utilsImports = ["StrapiBaseEntity"];
+  const attributesStr = JSON.stringify(collection.attributes);
+  if (attributesStr.includes('"type":"media"')) {
+    utilsImports.push("StrapiMedia");
+  }
+  if (attributesStr.includes('"type":"blocks"')) {
+    utilsImports.push("BlocksContent");
+  }
+  return `/**
+ * ${collection.displayName}
+ * ${collection.description || ""}
+ * Generated by strapi-integrate
+ */
+
+import type { ${utilsImports.join(", ")} } from '../utils';
+${dependencyImports ? dependencyImports + "\n" : ""}
+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;
+}
+
+export interface ${typeName}Sort {
+  field: keyof ${typeName};
+  order: 'asc' | 'desc';
+}
+`;
+}
+function generateSingleType(single, components) {
+  const typeName = toPascalCase(single.singularName);
+  const attributes = generateAttributes(single.attributes);
+  const { relations, components: componentDeps } = extractDependencies(single.attributes, typeName);
+  const dependencyImports = generateDependencyImports(relations, componentDeps);
+  const utilsImports = ["StrapiBaseEntity"];
+  const attributesStr = JSON.stringify(single.attributes);
+  if (attributesStr.includes('"type":"media"')) {
+    utilsImports.push("StrapiMedia");
+  }
+  if (attributesStr.includes('"type":"blocks"')) {
+    utilsImports.push("BlocksContent");
+  }
+  return `/**
+ * ${single.displayName}
+ * ${single.description || ""}
+ * Generated by strapi-integrate
+ */
+
+import type { ${utilsImports.join(", ")} } from '../utils';
+${dependencyImports ? dependencyImports + "\n" : ""}
+export interface ${typeName} extends StrapiBaseEntity {
+${attributes}
+}
+`;
+}
+function generateComponentType(component) {
+  const typeName = toPascalCase(component.name);
+  const attributes = generateAttributes(component.attributes);
+  const { relations, components: componentDeps } = extractDependencies(component.attributes, typeName);
+  const imports = [];
+  for (const relation of relations) {
+    const relTypeName = toPascalCase(relation);
+    const fileName = toKebabCase(relation);
+    imports.push(`import type { ${relTypeName} } from '../collections/${fileName}';`);
+  }
+  for (const comp of componentDeps) {
+    const compTypeName = toPascalCase(comp);
+    const fileName = toKebabCase(comp);
+    if (compTypeName !== typeName) {
+      imports.push(`import type { ${compTypeName} } from './${fileName}';`);
+    }
+  }
+  const utilsImports = [];
+  const attributesStr = JSON.stringify(component.attributes);
+  if (attributesStr.includes('"type":"media"')) {
+    utilsImports.push("StrapiMedia");
+  }
+  if (attributesStr.includes('"type":"blocks"')) {
+    utilsImports.push("BlocksContent");
+  }
+  const utilsImportLine = utilsImports.length > 0 ? `import type { ${utilsImports.join(", ")} } from '../utils';
+` : "";
+  const dependencyImports = imports.length > 0 ? imports.join("\n") + "\n" : "";
+  return `/**
+ * ${component.displayName} component
+ * Category: ${component.category}
+ * ${component.description || ""}
+ * Generated by strapi-integrate
+ */
+
+${utilsImportLine}${dependencyImports}
+export interface ${typeName} {
+  id: number;
+${attributes}
+}
+`;
+}
+function generateAttributes(attributes, components) {
+  const lines = [];
+  for (const [name, attr] of Object.entries(attributes)) {
+    const tsType = attributeToTsType(attr);
+    const optional = attr.required ? "" : "?";
+    const comment = getAttributeComment(attr);
+    if (comment) {
+      lines.push(`  /** ${comment} */`);
+    }
+    lines.push(`  ${name}${optional}: ${tsType};`);
+  }
+  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;
+  const generatedFiles = [];
+  await ensureDir(outputDir);
+  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));
+    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));
+    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: 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} Service
+ * ${collection.description || ""}
+ * Generated by strapi-integrate
+ * Strapi version: ${strapiVersion}
+ */
+
+${imports.join("\n")}
+
+export interface FindManyOptions {
+${findManyOptionsFields.join("\n")}
+}
+
+export interface FindOneOptions {
+${findOneOptionsFields.join("\n")}
+}
+
+// Create typed collection helper
+const ${toCamelCase(collection.singularName)}Collection = collection<${typeName}>('${endpoint}');
+
+export const ${serviceName} = {
+  /**
+   * Find multiple ${collection.pluralName}
+   */
+  async findMany(options: FindManyOptions = {}): Promise<{ data: ${typeName}[]; pagination: StrapiPagination }> {
+    const response = await ${toCamelCase(collection.singularName)}Collection.find({
+${findParams.join("\n")}
+    });
+
+    return {
+      data: response.data,
+      pagination: response.meta.pagination,
+    };
+  },
+
+  /**
+   * Find all ${collection.pluralName} (handles pagination automatically)
+   */
+  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;
+  },
+
+  /**
+   * 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 ? `
+  /**
+   * 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;
+  },
+` : ""}
+  /**
+   * Create a new ${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}
+   */
+  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}
+   */
+  async delete(${idParam}): Promise<void> {
+    await ${toCamelCase(collection.singularName)}Collection.delete(${idName});
+  },
+
+  /**
+   * Count ${collection.pluralName}
+   */
+  async count(filters?: ${typeName}Filters): Promise<number> {
+    const { pagination } = await this.findMany({
+      filters,
+      pagination: { pageSize: 1 },
+    });
+
+    return pagination.total;
+  },
+};
+`;
+}
+function generateSingleService(single, typesImportPath, strapiVersion) {
+  const typeName = toPascalCase(single.singularName);
+  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,`);
+  }
+  return `/**
+ * ${single.displayName} Service (Single Type)
+ * ${single.description || ""}
+ * Generated by strapi-integrate
+ * 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();
+  },
+};
+`;
+}
+async function generateActions(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 = path7.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 = path7.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 strapi-integrate
+ * Strapi version: ${strapiVersion}
+ */
+
+import { defineAction, ActionError } from 'astro:actions';
+import { z } from 'astro:schema';
+import { ${serviceName} } from '${servicesImportPath}/${fileName}.service';
+
+/**
+ * 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 all ${collection.pluralName} with pagination
+   */
+  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,
+        });
+
+        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: '${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}',
+        });
+      }
+    },
+  }),
+${hasSlug ? `
+  /**
+   * Get a single ${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',
+          });
+        }
+
+        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 strapi-integrate
+ */
+
+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({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to update ${single.singularName}',
+        });
+      }
+    },
+  }),
+};
+`;
+}
+async function generateClient(options) {
+  const { outputDir, strapiVersion = "v5" } = options;
+  const generatedFiles = [];
+  await ensureDir(outputDir);
+  const filePath = path7.join(outputDir, "client.ts");
+  const content = generateClientFile(strapiVersion);
+  await writeFile(filePath, await formatCode(content));
+  generatedFiles.push(filePath);
+  return generatedFiles;
+}
+function generateClientFile(strapiVersion) {
+  const isV4 = strapiVersion === "v4";
+  if (isV4) {
+    return generateV4ClientFile();
+  }
+  return generateV5ClientFile();
+}
+function generateV5ClientFile() {
+  return `/**
+ * Strapi Client (v5)
+ * Generated by strapi-integrate
+ */
+
+import Strapi from 'strapi-sdk-js';
+
+// 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;
+
+export const strapi = new Strapi({
+  url: strapiUrl,
+  axiosOptions: {
+    headers: strapiToken ? {
+      Authorization: \`Bearer \${strapiToken}\`,
+    } : {},
+  },
+});
+
+// Pagination type
+export interface StrapiPagination {
+  page: number;
+  pageSize: number;
+  pageCount: number;
+  total: number;
+}
+
+// Default pagination for fallback
+const defaultPagination: StrapiPagination = {
+  page: 1,
+  pageSize: 25,
+  pageCount: 1,
+  total: 0,
+};
+
+// Response types
+interface StrapiListResponse<T> {
+  data: T[];
+  meta: {
+    pagination?: StrapiPagination;
+  };
+}
+
+interface StrapiSingleResponse<T> {
+  data: T;
+  meta?: Record<string, unknown>;
+}
+
+// Helper to get typed collection
+export function collection<T>(pluralName: string) {
+  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 generateV4ClientFile() {
+  return `/**
+ * Strapi Client (v4)
+ * Generated by strapi-integrate
+ */
+
+import Strapi from 'strapi-sdk-js';
+
+// 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;
+
+export const strapi = new Strapi({
+  url: strapiUrl,
+  axiosOptions: {
+    headers: strapiToken ? {
+      Authorization: \`Bearer \${strapiToken}\`,
+    } : {},
+  },
+});
+
+// Pagination type
+export interface StrapiPagination {
+  page: number;
+  pageSize: number;
+  pageCount: number;
+  total: number;
+}
+
+// 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);
+    },
+  };
+}
+`;
+}
+async function generateLocales(locales, options) {
+  const { outputDir } = options;
+  const generatedFiles = [];
+  await ensureDir(outputDir);
+  const filePath = path7.join(outputDir, "locales.ts");
+  const content = generateLocalesFile(locales);
+  await writeFile(filePath, await formatCode(content));
+  generatedFiles.push(filePath);
+  return generatedFiles;
+}
+function generateLocalesFile(locales) {
+  if (locales.length === 0) {
+    return `/**
+ * Strapi Locales
+ * Generated by strapi-integrate
+ *
+ * Note: No locales found. i18n might not be enabled in Strapi.
+ */
+
+export const locales = [] as const;
+
+export type Locale = string;
+
+export const defaultLocale: Locale = 'en';
+
+export const localeNames: Record<string, string> = {};
+`;
+  }
+  const defaultLocale = locales.find((l) => l.isDefault)?.code || locales[0]?.code || "en";
+  const localeCodes = locales.map((l) => `'${l.code}'`).join(" | ");
+  const localeArray = locales.map((l) => `'${l.code}'`).join(", ");
+  const localeNames = locales.map((l) => `  '${l.code}': '${l.name}'`).join(",\n");
+  return `/**
+ * Strapi Locales
+ * Generated by strapi-integrate
+ */
+
+/**
+ * Available locale codes
+ */
+export const locales = [${localeArray}] as const;
+
+/**
+ * Locale type - union of all available locales
+ */
+export type Locale = ${localeCodes};
+
+/**
+ * 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" } = 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)));
+  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) {
+  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 strapi-integrate 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 strapi-integrate
+ * 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) {
+  const isV4 = strapiVersion === "v4";
+  if (isV4) {
+    return `/**
+ * Strapi Client (v4)
+ * Generated by strapi-integrate
+ */
+
+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;
+
+export const strapi = new Strapi({
+  url: strapiUrl,
+  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 strapi-integrate
+ */
+
+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;
+
+export const strapi = new Strapi({
+  url: strapiUrl,
+  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 strapi-integrate
+ * 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 strapi-integrate
+ */
+
+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 strapi-integrate
+ */
+
+${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 strapi-integrate
+ */
+
+${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 strapi-integrate
+ */
+
+${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");
+  }
+  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, `../../collections/${fileName}/types`);
+        } else if (isSingle) {
+          relationImports.set(typeName, `../../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 = attributeToTsType2(attr);
+    const optional = attr.required ? "" : "?";
+    lines.push(`  ${name}${optional}: ${tsType};`);
+  }
+  return lines.join("\n");
+}
+function attributeToTsType2(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 generateCollectionService2(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 strapi-integrate
+ * 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 generateSingleService2(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 strapi-integrate
+ * 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 strapi-integrate
+ * 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 };
+    },
+  }),
+
+  delete: defineAction({
+    input: z.object({
+      ${idParamName}: ${idInputSchema},
+    }),
+    handler: async (input) => {
+      await ${serviceName}.delete(input.${idParamName});
+      return { success: true };
+    },
+  }),
+};
+`;
+}
+
+export { deleteFile, ensureDir, fileExists, formatCode, formatJson, generateActions, generateByFeature, generateClient, generateLocales, generateServices, generateTypes, listFiles, pluralize, readFile, toCamelCase, toKebabCase, toPascalCase, writeFile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map