next-accelerate 1.0.0

package/dist/index.js

@@ -0,0 +1,3217 @@
+#!/usr/bin/env node
+
+// src/builders/resource-builder.ts
+import path4 from "path";
+
+// src/templates/forms/create-form.ts
+var formCreateTemplate = (resourceInSingular, resourceInPlural) => `
+  "use client";
+
+  import { useForm, FormProvider } from 'react-hook-form';
+  import { useRouter } from 'next/navigation';
+  import { yupResolver } from '@hookform/resolvers/yup';
+  import { formSchema, FormSchemaType } from './form-scheme';
+  import { InputCustom, InputRichTextEditor } from '@/components/Shared/Inputs';
+  import { toast } from 'react-toastify';
+  import { useEffect, useState } from 'react';
+  import { delay } from '@/utils/utils';
+
+  export const FormNew${resourceInSingular} = () => {
+    const router = useRouter();
+    const [photoFile, setPhotoFile] = useState<File | null>(null);
+    const [photoPreview, setPhotoPreview] = useState<string | null>(null);
+    const methods = useForm<FormSchemaType>({ resolver: yupResolver(formSchema), mode: 'onChange', defaultValues: { title: '', content: '' } });
+    const { handleSubmit, watch, formState: { isValid, isSubmitting } } = methods;
+    const titlePreview = watch('title')
+
+    const onSubmit = async (data: FormSchemaType) => {
+      try {
+        const response = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/${resourceInPlural.toLocaleLowerCase()}\`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(data),
+        });
+        const ${resourceInSingular.toLocaleLowerCase()} = await response.json();
+
+        if (response.status === 201 && Boolean(${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLocaleLowerCase()}Id) && photoFile) {
+          const formData = new FormData();
+          formData.append("photo", photoFile, photoFile.name);
+          toast.success("encaminhando imagem ...");
+          await delay(3000);
+          const uploadResp = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/images/posts/\${post.postId}\`, { method: "POST", body: formData });
+
+          if (uploadResp.ok) {
+            toast.success("Resource created successfully!");
+            router.refresh();
+            router.push("/manager");
+          }
+          else { toast.error("No photos were selected."); }
+        } else {
+          toast.error("Erro ao criar o recurso.");
+        }
+      } catch (err) {
+        toast.error("Error communicating with the server.");
+      }
+    };
+
+    const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+      const file = e.target.files?.[0] ?? null;
+      setPhotoFile(file);
+      if (file) {
+        const previewUrl = URL.createObjectURL(file);
+        setPhotoPreview(previewUrl);
+      } else {
+        setPhotoPreview(null);
+      }
+    };
+
+
+    useEffect(() => {
+      return () => {
+        if (photoPreview) {
+          URL.revokeObjectURL(photoPreview);
+        }
+      };
+    }, [photoPreview]);
+
+    return (
+      <FormProvider {...methods}>
+        <form onSubmit={handleSubmit(onSubmit)} className="max-w-6xl mx-auto px-6 py-4 flex flex-col gap-6">
+          {/* Preview title */}
+          <h1 className="text-3xl font-bold text-(--textcolor)">{titlePreview || 'Pr\xE9via do t\xEDtulo do post'}</h1>
+          {/* title */}
+          <InputCustom name="title" label="T\xEDtulo do post" required />
+
+          {photoPreview && (
+            <div className="mt-4 w-full h-64 rounded-lg overflow-hidden border border-gray-200">
+              <img src={photoPreview} alt="Pr\xE9via da imagem" className="w-full h-full object-cover" />
+            </div>
+          )}
+
+          <div >
+            <label className="block text-sm font-medium text-gray-700">Imagem de exibi\xE7\xE3o do Post</label>
+            <input type="file" accept="image/*" onChange={handleFileChange} className="mt-2 border border-dashed rounded-lg p-2 w-full" />
+            {photoFile && <p className="text-sm text-green-600 mt-1">{photoFile.name}</p>}
+          </div>
+
+          {/* CONTENT */}
+          <InputRichTextEditor name="content" label="Conte\xFAdo" placeholder="Escreva seu post..." />
+
+          {/* BOTTOM BAR */}
+          <div className="sticky bottom-0 border-t pt-4 flex justify-between items-center">
+            <span className="text-sm text-gray-500">
+              Tem certeza que quer criar esse post?
+            </span>
+
+            <div className="flex gap-3">
+              <button type="button" className="text-sm px-4 py-2 rounded-md hover:bg-gray-100">
+                Cancelar
+              </button>
+              <button type="submit" disabled={!isValid || isSubmitting} className="px-6 py-2 bg-blue-700 text-white disabled:bg-gray-600 rounded-md hover:bg-blue-400">
+                Criar
+              </button>
+            </div>
+          </div>
+        </form>
+      </FormProvider>
+    );
+  };
+
+`;
+
+// src/templates/forms/schems/create-form-scheme.ts
+var formSchemeCreateTemplate = () => `
+import * as yup from 'yup';
+
+export const formSchema = yup.object({
+  title: yup.string().required('T\xEDtulo \xE9 obrigat\xF3rio'),
+  content: yup.string().required('Conte\xFAdo \xE9 obrigat\xF3rio'),
+});
+
+export type FormSchemaType = yup.InferType<typeof formSchema>;
+`;
+
+// src/templates/forms/delete-form.ts
+var formDeleteTemplate = (resourceInSingular, resourceInPlural) => `
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useEffect } from "react";
+import { toast } from "react-toastify";
+
+type FormDeleteResourceProps = { resource: string; resourceId: string; routerLinkCancel?: string; };
+
+export const FormDeleteResource: React.FC<FormDeleteResourceProps> = ({ resource, resourceId, routerLinkCancel }) => {
+  const router = useRouter();
+  useEffect(() => {}, [resourceId, resource]);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    try {
+      const response = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/delete/\${resource}/\${resourceId}\`, { method: "POST" });
+      if (response.ok) {
+        toast.success("Deleted successfully!");
+        router.push("/manager");
+      }
+      else {
+        toast.error("Erro ao deletar recurso");
+         router.push("/manager");
+      };
+
+    } catch (error) {
+      console.log(error);
+    }
+  };
+
+  const onCancel = () => {
+    if (routerLinkCancel) {
+      router.push(routerLinkCancel);
+    } else {
+      router.back();
+    }
+  }
+
+  return (
+    <form onSubmit={handleSubmit} className="flex justify-center gap-4 py-3">
+      <button type="button" onClick={onCancel} className="px-4 py-2 rounded bg-gray-300">
+        Cancelar
+      </button>
+
+      <button type="submit" className="px-4 py-2 rounded bg-red-600 text-white">
+        Confirmar e Deletar
+      </button>
+    </form>
+  );
+};
+`;
+
+// src/templates/forms/update-form.ts
+var formUpdateTemplate = (resourceInSingular, resourceInPlural) => `
+"use client";
+
+import { useEffect, useState } from "react";
+import { toast } from "react-toastify";
+import { FormProvider, useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useRouter } from "next/navigation";
+import { ${resourceInSingular} } from "@/utils/models/${resourceInPlural.toLocaleLowerCase()}";
+import { formSchema, FormSchemaType } from "./form-scheme";
+import { InputCustom } from "@/components/Inputs/InputCustom";
+import { InputRichTextEditor } from "@/components/Inputs/InputRichTextEditor";
+import { delay } from "@/utils/utils";
+
+type FormEdit${resourceInSingular}Props = { ${resourceInSingular.toLocaleLowerCase()}: ${resourceInSingular}; };
+export const FormEdit${resourceInSingular}: React.FC<FormEdit${resourceInSingular}Props> = ({ ${resourceInSingular.toLocaleLowerCase()} }) => {
+  const router = useRouter();
+  const [photoFile, setPhotoFile] = useState<File | null>(null);
+  const [photoPreview, setPhotoPreview] = useState<string | null>(${resourceInSingular.toLocaleLowerCase()}.image ? \`\${process.env.NEXT_PUBLIC_BACKEND_URL}\${${resourceInSingular.toLocaleLowerCase()}.image}\` : null);
+  const methods = useForm<FormSchemaType>({
+    resolver: yupResolver(formSchema), mode: "onChange",
+    defaultValues: { title: ${resourceInSingular.toLocaleLowerCase()}.title, content: ${resourceInSingular.toLocaleLowerCase()}.content, status: ${resourceInSingular.toLocaleLowerCase()}.status },
+  });
+
+  const { handleSubmit, watch, formState: { isSubmitting } } = methods;
+  const titlePreview = watch("title");
+  const onSubmit = async (data: FormSchemaType) => {
+    const payload = Object.fromEntries(Object.entries(data).filter(([_, value]) => value !== undefined));
+    if (Object.keys(payload).length === 0 && !photoFile) {
+      toast.info("Nenhuma altera\xE7\xE3o para salvar");
+      return;
+    }
+
+    try {
+      const response = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/${resourceInSingular.toLocaleLowerCase()}/\${${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLocaleLowerCase()}Id}\`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) { toast.error("Erro ao atualizar o ${resourceInSingular.toLocaleLowerCase()}"); return; };
+
+      if (photoFile) {
+        const formData = new FormData();
+        formData.append("photo", photoFile, photoFile.name);
+        await delay(3000);
+        const uploadResp = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/images/${resourceInSingular.toLocaleLowerCase()}/\${${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLocaleLowerCase()}Id}\`, { method: "POST", body: formData });
+        if (!uploadResp.ok) {
+          toast.warning("os dados do ${resourceInSingular.toLocaleLowerCase()} foram salvos, mas a imagem n\xE3o foi possivel carregar e atualizar, tente novamente...");
+          router.refresh();
+          return;
+        }
+      }
+
+      toast.success("${resourceInSingular} atualizado com sucesso!");
+      router.push("/manager")
+    } catch {
+      toast.error("Erro ao comunicar com o servidor");
+    }
+  };
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0] ?? null;
+    if (photoPreview?.startsWith("blob:")) {
+      URL.revokeObjectURL(photoPreview);
+    }
+    setPhotoFile(file);
+    if (file) {
+      setPhotoPreview(URL.createObjectURL(file));
+    }
+  };
+
+  useEffect(() => {
+    return () => {
+      if (photoPreview?.startsWith("blob:")) URL.revokeObjectURL(photoPreview);
+    };
+  }, [photoPreview]);
+
+  return (
+    <FormProvider {...methods}>
+      <form onSubmit={handleSubmit(onSubmit)} className="max-w-6xl mx-auto px-6 py-4 flex flex-col gap-6">
+        <h1 className="text-3xl font-bold">
+          {titlePreview || "Pr\xE9via do t\xEDtulo do ${resourceInSingular}"}
+        </h1>
+        <InputCustom name="title" label="T\xEDtulo do ${resourceInSingular}" />
+        {photoPreview && (<img src={photoPreview} className="h-64 w-full object-cover rounded-lg" alt="Pr\xE9via" />)}
+
+        <input type="file" accept="image/*" onChange={handleFileChange} />
+        <InputRichTextEditor name="content" label="Conte\xFAdo" placeholder="Atualize o conte\xFAdo do ${resourceInSingular}..." />
+
+        <button type="submit" disabled={isSubmitting} className="bg-blue-700 text-white px-6 py-2 rounded-md disabled:opacity-50"> Salvar
+        </button>
+      </form>
+    </FormProvider>
+  );
+};
+
+`;
+
+// src/templates/forms/schems/update-form-scheme.ts
+var formSchemeUpdateTemplate = (resourceInSingular, resourceInPlural) => `
+import * as yup from "yup";
+import { ${resourceInSingular}Status } from "@/utils/models/${resourceInSingular.toLocaleLowerCase()}";
+// ${resourceInPlural} se tiver campo "imagem" lembrar nao incluir, uploadde imagem pesada deve ser feita separadamente
+
+export const formSchema = yup.object({
+  title: yup.string().transform((value) => (value === "" ? undefined : value)).min(3, "O t\xEDtulo deve ter pelo menos 3 caracteres").max(150, "O t\xEDtulo deve ter no m\xE1ximo 150 caracteres").nullable().defined(),
+  content: yup.string().transform((value) => (value === "" ? undefined : value)).min(10, "O conte\xFAdo deve ter pelo menos 10 caracteres").nullable().defined(),
+  status: yup.mixed<${resourceInSingular}Status>().oneOf(Object.values(${resourceInSingular}Status)).nullable().defined(),
+});
+
+export type FormSchemaType = yup.Asserts<typeof formSchema>;
+`;
+
+// src/templates/pages/detail-page.ts
+var detailPageTemplate = (resourceInSingular) => `
+  interface PageProps {params: {${resourceInSingular.toLocaleLowerCase()}Id: string;};};
+
+  export default function ${resourceInSingular}DetailPage({ params }: PageProps) {
+    const { ${resourceInSingular.toLocaleLowerCase()}Id } = params;
+    return (
+      <div className="w-full min-h-screen flex flex-col bg-[--bg-section-100] p-10 transition-colors duration-500">
+        ${resourceInSingular} detail: {${resourceInSingular.toLocaleLowerCase()}Id}
+      </div>
+    );
+  }
+`;
+
+// src/templates/pages/list-page.ts
+var listPageTemplate = (resourceInSingular, resourceInPlural) => `
+  // import { ${resourceInSingular} } from "@/utils/models/${resourceInPlural.toLocaleLowerCase()}";
+  import Link from "next/link";
+  import { FileCogIcon, FileText } from "lucide-react";
+
+  type ${resourceInSingular} = {};
+  async function get${resourceInPlural.toLocaleLowerCase()}(): Promise<${resourceInSingular}[]> {
+    const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/${resourceInPlural.toLowerCase()}\`, {
+      cache: "no-store",
+    });
+    if (!response.ok) return [];
+    const ${resourceInPlural.toLocaleLowerCase()}: ${resourceInSingular}[] = await response.json();
+    return ${resourceInPlural.toLocaleLowerCase()};
+  }
+
+  export default async function ${resourceInPlural}Page() {
+    const ${resourceInPlural.toLocaleLowerCase()}: ${resourceInSingular}[] = await get${resourceInPlural.toLocaleLowerCase()}();
+
+    return (
+      <div className="w-full min-h-screen bg-[--bg-section-100] p-10 transition-colors duration-500">
+        <div className="max-w-6xl mx-auto">
+          {/* Header */}
+          <header className="flex items-center justify-between mb-10">
+            <div className="flex items-center gap-3">
+              <div className="p-2 rounded-xl bg-primary/10 text-primary">
+                <FileText className="w-6 h-6" />
+              </div>
+              <div>
+                <h1 className="text-3xl font-semibold">${resourceInPlural}</h1>
+                <p className="text-muted-foreground">
+                  Lista de ${resourceInPlural.toLocaleLowerCase()} publicados na aplica\xE7\xE3o
+                </p>
+              </div>
+            </div>
+          </header>
+
+          {/* ${resourceInPlural} list */}
+          <section className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
+            {${resourceInPlural.toLocaleLowerCase().toLocaleLowerCase()}.map((${resourceInSingular.toLocaleLowerCase()}: ${resourceInSingular}) => (
+              <article key={${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLocaleLowerCase()}Id} className="rounded-2xl bg-background p-6 shadow-sm hover:shadow-md transition-shadow flex flex-col justify-between">
+                <div className="flex items-start gap-3">
+                  <div className="p-2 w-full bg-muted text-muted-foreground ">
+                    <h2 className="font-semibold text-lg leading-snug">
+                      {${resourceInSingular.toLocaleLowerCase()}.title}
+                    </h2>
+                    <div className="flex items-center justify-between">
+                      <FileText className="w-5 h-5" />
+                      <Link href={\`/${resourceInPlural.toLocaleLowerCase()}/\${${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLowerCase()}Id}/config\`} className="cursor-pointer p-2 hover:bg-amber-400 rounded-2xl">
+                        <FileCogIcon className="w-5 h-5" />
+                      </Link>
+                    </div>
+
+                  </div>
+                </div>
+                <div className="flex items-center justify-around">
+                <Link href={\`/${resourceInPlural.toLocaleLowerCase()}/\${${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLocaleLowerCase()}Id}/edit\`} >editar</Link>
+                <Link href={\`/${resourceInPlural.toLocaleLowerCase()}/\${${resourceInSingular.toLocaleLowerCase()}.${resourceInSingular.toLocaleLowerCase()}Id}/delete\`} >excluir</Link>
+              </div>
+
+              </article>
+            ))}
+          </section>
+
+          {/* Empty state */}
+          {${resourceInPlural.toLocaleLowerCase()}.length === 0 && (
+            <div className="mt-20 text-center text-muted-foreground">
+              <FileText className="w-10 h-10 mx-auto mb-3 opacity-50" />
+              <p>Nenhum ${resourceInSingular.toLocaleLowerCase()} encontrado</p>
+            </div>
+          )}
+        </div>
+      </div>
+    );
+  };
+`;
+
+// src/templates/pages/new-page.ts
+var newPageTemplate = (resourceInSingular, resourceInPlural) => `
+  import { FilePlus2, Info } from "lucide-react";
+  import { authOptions } from "@/app/api/auth/[...nextauth]/route";
+  import { Session } from "@/utils/route";
+  import { getServerSession } from "next-auth";
+  import { redirect } from "next/navigation";
+  import { FormNew${resourceInSingular} } from "@/forms/${resourceInPlural.toLocaleLowerCase()}";
+
+  export default async function New${resourceInSingular}Page() {
+    const session: Session | null = await getServerSession(authOptions);
+    if (!session) redirect("/");
+
+    return (
+      <div className="w-full min-h-screen bg-[--bg-section-100] transition-colors duration-500">
+        <div className="max-w-4xl mx-auto px-6 py-12">
+          <header className="mb-10">
+            <div className="flex items-start gap-4">
+              <div className="p-3 rounded-2xl bg-primary/10 text-primary">
+                <FilePlus2 className="w-6 h-6" />
+              </div>
+              <div>
+                <h1 className="text-3xl font-semibold">Criar novo post</h1>
+                <p className="mt-1 text-muted-foreground max-w-2xl">
+                  Preencha as informa\xE7\xF5es abaixo para publicar um novo post no blog.
+                  Capriche no t\xEDtulo e no conte\xFAdo para melhorar a leitura e o
+                  engajamento.
+                </p>
+              </div>
+            </div>
+          </header>
+
+          {/* Info helper */}
+          <section className="mb-12 rounded-2xl bg-background shadow-sm p-6 flex gap-3">
+            <Info className="w-5 h-5 text-muted-foreground mt-0.5" />
+            <p className="text-sm text-muted-foreground">
+              Voc\xEA pode editar este ${resourceInSingular.toLowerCase()} depois de publicado. Certifique-se de revisar
+              o conte\xFAdo antes de salvar.
+            </p>
+          </section>
+
+          <FormNew${resourceInSingular} />
+        </div>
+      </div>
+    );
+  }
+`;
+
+// src/templates/pages/manager-page.ts
+var managerPageTemplate = () => `
+import { authOptions } from "@/app/api/auth/[...nextauth]/route";
+import { Session } from "@/utils/route";
+import { getServerSession } from "next-auth";
+import { redirect } from "next/navigation";
+
+export default async function Manager() {
+  const session: Session | null = await getServerSession(authOptions);
+  if (!session) redirect("/");
+
+  return (
+    <div className="w-full min-h-screen relative bg-(--bg-section-100) transition-colors duration-500 p-6">
+      <h2>Bora major.catuca nesse freelas..</h2>
+    </div >
+  );
+};
+`;
+
+// src/templates/routes/manager-context.ts
+var managerContextTemplate = () => `
+"use client";
+
+import { createContext, useContext, useState, ReactNode } from "react";
+
+type MenuContextType = {
+  menuActive: boolean;
+  setMenuActive: (value: boolean) => void;
+};
+
+const MenuContext = createContext<MenuContextType | undefined>(undefined);
+
+export const MenuProvider = ({ children }: { children: ReactNode }) => {
+  const [menuActive, setMenuActive] = useState(true);
+  return (
+    <MenuContext.Provider value={{ menuActive, setMenuActive }}>
+      {children}
+    </MenuContext.Provider>
+  );
+};
+
+export const useMenu = () => {
+  const context = useContext(MenuContext);
+  if (!context) throw new Error("useMenu must be used within MenuProvider");
+  return context;
+};
+`;
+
+// src/templates/inputs/input-template.ts
+var inputTemplate = () => `
+  "use client";
+  import { useFormContext, Controller } from 'react-hook-form';
+
+  interface InputProps {
+    name: string;
+    label: string;
+    type?: string;
+    required?: boolean;
+    ishidden?: boolean;
+    pattern?: RegExp;
+    placeholder?: string;
+    asDate?: boolean;
+    multiline?: boolean;
+  }
+
+  export const InputCustom: React.FC<InputProps> = ({ name, label, type = "text", required, pattern, placeholder, asDate, ishidden, multiline = false }) => {
+    const { control, formState: { errors } } = useFormContext();
+
+    return (
+      <div className="flex flex-col gap-2">
+        {!ishidden && (
+          <label htmlFor={name} className="text-sm font-medium text-[--text-label]">
+            {label}:
+          </label>
+        )}
+
+        <Controller
+          control={control}
+          name={name}
+          rules={{
+            required: !ishidden && required ? "Campo obrigat\xF3rio" : false,
+            pattern: pattern ? { value: pattern, message: "Formato inv\xE1lido" } : undefined,
+          }}
+          render={({ field }) => {
+            const value = asDate && typeof field.value === "string" ? field.value.split("T")[0] : field.value ?? "";
+            const baseClasses = "w-full p-2 px-3 mt-1 border shadow-sm outline-none transition-all focus:border-blue-300 focus:ring-1 focus:ring-blue-300";
+            const errorClass = errors[name] ? "border-red-400" : "border-gray-300";
+
+            if (multiline) {
+              return (
+                <textarea {...field} id={name} rows={5} placeholder={placeholder} value={value} onChange={field.onChange} className={\`\${baseClasses} \${errorClass} rounded-xl resize-y min-h-30\`}/>
+              );
+            }
+
+            return (
+              <input {...field} id={name} type={type} placeholder={ishidden ? "" : placeholder} hidden={ishidden} aria-hidden={ishidden} value={value} onChange={(e) => {
+                  if (asDate) {
+                    const v = e.target.value;
+                    if (!v) {
+                      field.onChange(null);
+                      return;
+                    }
+                    const date = new Date(v);
+                    if (isNaN(date.getTime())) return;
+
+                    field.onChange(date.toISOString());
+                  } else {
+                    field.onChange(e);
+                  }
+                }}
+                className={\`\${baseClasses} \${errorClass} rounded-full\`}
+              />
+            );
+          }}
+        />
+        {errors[name]?.message && (
+          <p className="text-sm text-red-500">
+            {errors[name]?.message as string}
+          </p>
+        )}
+      </div>
+    );
+  };
+`;
+var inputFormHelperTestUnitTemplate = () => `
+import { ReactNode } from "react";
+import { render } from "@testing-library/react";
+import { useForm, FormProvider } from "react-hook-form";
+
+export function renderWithForm(ui: ReactNode) {
+    const Wrapper = ({ children }: { children: ReactNode }) => {
+        const methods = useForm();
+
+        return (
+            <form onSubmit={methods.handleSubmit(() => { })}>
+                <FormProvider {...methods}>
+                    {children}
+                    <button type="submit">submit</button>
+                </FormProvider>
+            </form>
+        );
+
+    };
+
+    return render(ui, { wrapper: Wrapper });
+}`;
+var inputTestUnitTemplate = () => `
+import { screen, fireEvent } from "@testing-library/react";
+import { InputCustom } from ".";
+import { renderWithForm } from "./renderWithForm";
+
+describe("InputCustom component", () => {
+
+    it("should render the label and the input.", () => {
+        renderWithForm(<InputCustom name="email" label="Email" placeholder="Digite o email" />);
+
+        expect(screen.getByLabelText("Email:")).toBeInTheDocument();
+        expect(screen.getByPlaceholderText("Digite o email")).toBeInTheDocument();
+
+    });
+
+    it("should allows you to type in the field", () => {
+        renderWithForm(<InputCustom name="name" label="Nome" placeholder="Digite seu nome" />);
+
+        const input = screen.getByPlaceholderText("Digite seu nome");
+
+        fireEvent.change(input, { target: { value: "Jo\xE3o" } });
+
+        expect(input).toHaveValue("Jo\xE3o");
+
+    });
+
+    it("should shows error when required.", async () => {
+        renderWithForm(<InputCustom name="name" label="Nome" required />);
+
+        fireEvent.click(screen.getByText("submit"));
+
+        expect(await screen.findByText("Campo obrigat\xF3rio")).toBeInTheDocument();
+
+    });
+
+    it("should validate pattern", async () => {
+        renderWithForm(<InputCustom name="cpf" label="CPF" pattern={/^d{3}$/} placeholder="123" />);
+
+        const input = screen.getByPlaceholderText("123");
+
+        fireEvent.change(input, { target: { value: "abc" } });
+        fireEvent.click(screen.getByText("submit"));
+
+        expect(await screen.findByText("Formato inv\xE1lido")).toBeInTheDocument();
+
+    });
+
+    it("should renders textarea", () => {
+        renderWithForm(<InputCustom name="bio" label="Bio" multiline />);
+
+        const textarea = screen.getByRole("textbox");
+        expect(textarea.tagName).toBe("TEXTAREA");
+
+    });
+
+});
+
+`;
+
+// src/templates/routes/nextauth-route.ts
+var nextConfigTemplate = () => `
+import NextAuth, { NextAuthOptions } from "next-auth";
+import CredentialsProvider from "next-auth/providers/credentials";
+import { cookies } from "next/headers";
+import { IAuthenticateUser, requestAuthenticationUser } from "../request-api";
+import { decoderTokenToClaims } from "../decode-claims";
+
+export type User = { id: string; name: string; email: string; image: string; userStatus?: string; accessToken: string; };
+
+export const authOptions: NextAuthOptions = {
+    pages: {
+        signIn: "/",
+    },
+    providers: [
+        CredentialsProvider({
+            name: "Credentials",
+            credentials: {
+                email: { label: "Email", type: "email", placeholder: "example@gmail.com" },
+                password: { label: "Password", type: "password" },
+            },
+            async authorize(credentials, req): Promise<User | null> {
+                const user: IAuthenticateUser = {
+                    email: credentials?.email,
+                    password: credentials?.password,
+                    clientType: "web",
+                };
+                const resposta = await requestAuthenticationUser(user);
+
+                if (resposta.accessToken && resposta.accessToken !== "User with credentials not found or invalid") {
+                    (await cookies()).set("jwt_back", resposta.accessToken, { httpOnly: true, sameSite: "lax", path: "/", maxAge: 3600 });
+                    (await cookies()).set("jwt_back_refresh", resposta.refreshToken, { httpOnly: true, sameSite: "lax", path: "/", maxAge: 3600 });
+
+                    const decodedClaims = decoderTokenToClaims(resposta.accessToken);
+                    return { id: decodedClaims?.id ?? "", name: decodedClaims?.username ?? "", email: decodedClaims?.email ?? "", image: decodedClaims?.imagem ?? "", userStatus: decodedClaims?.userStatus ?? "unknown", accessToken: resposta.accessToken } as User;
+                }
+                return null;
+            },
+        }),
+    ],
+
+    callbacks: {
+        async jwt({ token, user, trigger, session }) {
+            if (user) {
+                const u = user as any;
+                token.id = u.id ?? "";
+                token.name = u.name ?? "";
+                token.email = u.email ?? "";
+                token.image = u.image ?? "";
+                token.userStatus = u.userStatus ?? "";
+                if ("accessToken" in u) token.accessToken = u.accessToken ?? "";
+            }
+
+            if (trigger === "update" && session?.user) {
+                token.name = session.user.name ?? token.name;
+                token.email = session.user.email ?? token.email;
+                token.image = session.user.image ?? token.image;
+                token.userStatus = session.user.userStatus ?? token.userStatus;
+            }
+
+            return token;
+        },
+        async session({ session, token }) {
+            if (session.user) {
+                (session.user as any).id = (token as any).id;
+                session.user.name = (token as any).name;
+                session.user.email = (token as any).email;
+                const image = typeof (token as any).image === "string" ? (token as any).image : undefined;
+                session.user.image = image;
+                (session.user as any).userStatus = (token as any).userStatus;
+            }
+            (session as any).accessToken = (token as any).accessToken ?? null;
+            return session;
+        },
+    },
+};
+
+const handler = NextAuth(authOptions);
+export { handler as GET, handler as POST };
+
+`;
+
+// src/templates/config/decode-claims.ts
+var nextDecodeClaimsTemplate = () => `
+import { jwtDecode } from 'jwt-decode';
+
+export interface IObjectClaims { id: string; username: string; email: string; imagem: string; roles: string | string[]; userStatus?: string; };
+
+export const decoderTokenToClaims = (token: string): Partial<IObjectClaims> | null => {
+    if (token) {
+        try {
+            const decodedToken = jwtDecode(token) as any;
+            return { id: decodedToken.userId, username: decodedToken.userName, email: decodedToken.email, imagem: decodedToken.image, roles: decodedToken.roles, userStatus: decodedToken.userStatus };
+        } catch (error) {
+            return null;
+        }
+    } else {
+        return null;
+    }
+}
+`;
+
+// src/templates/config/request-api.ts
+var nextRequestApiTemplate = () => `
+export interface IAuthenticateUser { email: string | undefined; password: string | undefined; clientType: string; };
+
+export const requestAuthenticationUser = async (user: IAuthenticateUser) => {
+    const resposta = await fetch(\`\${process.env.NEXT_BACKEND_URL}/auth/login\`, {
+        method: 'POST',
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(user)
+    });
+    if (resposta.ok) return await resposta.json();
+    return null;
+
+};
+`;
+
+// src/templates/config/session.ts
+var nextSessionTypeTemplate = () => `
+ export interface Session {
+    user: { name: string; email: string; image: string; id: string; userStatus: string; };
+    accessToken: string;
+}
+ `;
+
+// src/templates/config/utils.ts
+var utilsTypeTemplate = () => `export const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));`;
+
+// src/templates/config/environment.ts
+var environmentTemplate = () => `
+NEXTAUTH_URL=http://localhost:3000
+NEXTAUTH_SECRET=secret_key
+
+NEXT_FRONTEND_URL=http://localhost:3000
+NEXT_PUBLIC_FRONTEND_URL=http://localhost:3000
+
+NEXT_BACKEND_URL=http://localhost:8000
+NEXT_PUBLIC_BACKEND_URL=http://localhost:8000
+
+`;
+
+// src/templates/routes/image-upload-route.ts
+var imageUploadTemplate = () => `
+import { NextRequest, NextResponse } from "next/server";
+import { cookies } from "next/headers";
+
+export async function POST(req: NextRequest, context: { params: Promise<{ resource: string; resourceId: string }> }) {
+  const { resource, resourceId } = await context.params;
+
+  try {
+    const cookieStore = cookies();
+    const token = (await cookieStore).get("jwt_back");
+    const jwt = token?.value ?? "not found";
+    const backendForm = new FormData();
+    const formData = await req.formData();
+    const photo = formData.get("photo");
+
+    if (photo && photo instanceof Blob) {
+      backendForm.append("file", photo);
+    } else {
+      return NextResponse.json({ message: "Nenhuma foto enviada" }, { status: 400 });
+    }
+
+    const init: RequestInit & { duplex?: 'half' } = {
+      method: "PATCH",
+      headers: {
+        Authorization: \`Bearer \${jwt}\`,
+      },
+      body: backendForm,
+      duplex: "half",
+    };
+
+    const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/\${resource}/\${resourceId}/photo\`, init);
+    const data = await response.json();
+    return NextResponse.json(data, { status: response.status });
+
+  } catch (err) {
+    console.error("Erro no route handler:", err);
+    return NextResponse.json({ message: "Erro ao conectar no backend" }, { status: 500 });
+  }
+}
+`;
+
+// src/templates/routes/delete-route.ts
+var deleteTemplate = () => `
+import { NextRequest, NextResponse } from "next/server";
+import { cookies } from "next/headers";
+
+export async function POST(req: NextRequest, context: { params: Promise<{ resource: string; resourceId: string }> }) {
+  const { resource, resourceId } = await context.params;
+
+  try {
+    const cookieStore = cookies();
+    const token = (await cookieStore).get("jwt_back");
+    const jwt = token?.value ?? "not found";
+
+    const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/\${resource}/\${resourceId}\`, {
+      method: "DELETE",
+      headers: {
+        Authorization: \`Bearer \${jwt}\`,
+      },
+    });
+    console.log("Response status from backend:", response.status);
+    return NextResponse.json({ status: response.status });
+
+  } catch (err) {
+    console.error("Erro no route handler:", err);
+    return NextResponse.json({ message: "Erro ao conectar no backend" }, { status: 500 });
+  }
+}
+
+`;
+
+// src/templates/routes/set-user-photo-route.ts
+var usersPhotoTemplate = () => `
+import { NextRequest, NextResponse } from "next/server";
+import { cookies } from "next/headers";
+import { decoderTokenToClaims } from "../../auth/decode-claims";
+
+export async function POST(req: NextRequest) {
+  try {
+    const cookieStore = cookies();
+    const token = (await cookieStore).get("jwt_back");
+    const jwt = token?.value ?? "not found";
+    const backendForm = new FormData();
+
+    const formData = await req.formData();
+    const photo = formData.get("photo");
+
+    if (photo && photo instanceof Blob) {
+      backendForm.append("photo", photo);
+    } else {
+      return NextResponse.json({ message: "Nenhuma foto enviada" }, { status: 400 });
+    }
+    const user = decoderTokenToClaims(jwt);
+    const init: RequestInit & { duplex?: 'half' } = {
+      method: "PATCH",
+      headers: {
+        Authorization: \`Bearer \${jwt}\`,
+      },
+      body: backendForm,
+      duplex: "half",
+    };
+
+    const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/users/\${user?.id}/photo\`, init);
+    const data = await response.json();
+    return NextResponse.json(data, { status: response.status });
+
+  } catch (err) {
+    console.error("Erro no route handler:", err);
+    return NextResponse.json({ message: "Erro ao conectar no backend" }, { status: 500 });
+  }
+}
+`;
+
+// src/templates/routes/user-create-route.ts
+var usersCreateTemplate = () => `
+import { NextRequest, NextResponse } from "next/server";
+
+export async function POST(req: NextRequest): Promise<NextResponse> {
+    try {
+        const body = await req.json();
+
+        const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/users\`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        const contentType = response.headers.get("Content-Type");
+        const usuario = await response.json();
+        console.log(contentType);
+        console.log(JSON.stringify(usuario));
+        
+        if (response.status === 201) {
+            return NextResponse.json(usuario, { status: 201 });
+        }
+        console.log(response.status);
+        return NextResponse.json({ message: "The request contains errors, such as invalid data, incorrect format, or missing required fields." }, { status: 400 });
+
+    } catch (error) {
+        throw new Error("Erro ao conectar no backend.");
+    }
+}
+`;
+
+// src/templates/routes/user-update-route.ts
+var usersUpdateTemplate = () => `
+import { NextRequest, NextResponse } from "next/server";
+import { cookies } from "next/headers";
+import { decoderTokenToClaims } from "../../auth/decode-claims";
+
+export async function POST(req: NextRequest): Promise<NextResponse> {
+    try {
+        const cookieStore = cookies();
+        const token = (await cookieStore).get("jwt_back");
+        let jwt = !token ? "not found" : token.value;
+
+        const refreshtoken = (await cookieStore).get("jwt_back_refresh");
+        let refreshJwt = !refreshtoken ? "not found" : refreshtoken.value;
+        if (!jwt || !refreshJwt)
+            return NextResponse.json({ message: "Token n\xE3o encontrado." }, { status: 401 });
+
+        const user = decoderTokenToClaims(jwt);  // usuario que esta enviando atualiza\xE7\xE3o
+        const body = await req.json();           // a atualiza\xE7\xE3o
+
+        // Atualiza o usu\xE1rio
+        const response = await fetch(\`\${process.env.NEXT_PUBLIC_BACKEND_URL}/users/\${user?.id}\`, {
+            method: "PATCH",
+            headers: {
+                Authorization: \`Bearer \${jwt}\`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+
+        if (!response.ok) {
+            return NextResponse.json({ message: "Erro ao atualizar usu\xE1rio." }, { status: response.status });
+        }
+
+        // Agora pede um novo accessToken atualizado
+        const refreshRes = await fetch(\`\${process.env.NEXT_PUBLIC_BACKEND_URL}/auth/refresh\`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken: refreshJwt, clientType: "web" }),
+        });
+
+        if (!refreshRes.ok) {
+            return NextResponse.json({ message: "Erro ao atualizar token." }, { status: refreshRes.status });
+        }
+        const newTokens = await refreshRes.json();
+        (await cookieStore).set("jwt_back", newTokens.accessToken, { httpOnly: true, sameSite: "lax", path: "/", maxAge: 3600, });
+        const decoded = decoderTokenToClaims(newTokens.accessToken);
+        
+        // Retorna tudo pro front (pra atualizar a sess\xE3o)
+        return NextResponse.json({ user: { id: decoded?.id, name: decoded?.username, email: decoded?.email, image: decoded?.imagem, userStatus: decoded?.userStatus, }, accessToken: newTokens.accessToken }, { status: 200 });
+    } catch (error) {
+        console.error(error);
+        return NextResponse.json({ message: "Erro ao conectar no backend." }, { status: 500 });
+    }
+}
+`;
+
+// src/templates/routes/create-resource-route.ts
+var createResourceTemplate = (resourceInPlural) => `
+import { NextRequest, NextResponse } from "next/server";
+import { cookies } from "next/headers";
+import { decoderTokenToClaims } from "../auth/decode-claims";
+
+export async function POST(req: NextRequest): Promise<NextResponse> {
+
+    try {
+        const cookieStore = cookies();
+        const token = (await cookieStore).get("jwt_back");
+        let jwt = !token ? "not found" : token.value;
+
+        const refreshtoken = (await cookieStore).get("jwt_back_refresh");
+        let refreshJwt = !refreshtoken ? "not found" : refreshtoken.value;
+        if (!jwt || !refreshJwt) return NextResponse.json({ message: "Token n\xE3o encontrado." }, { status: 401 });
+
+        const user = decoderTokenToClaims(jwt);
+        const body = await req.json();
+        const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/${resourceInPlural.toLocaleLowerCase()}\`, {
+            method: 'POST',
+            headers: {
+                Authorization: \`Bearer \${jwt}\`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ ...body, userId: user?.id }),
+        });
+        const contentType = response.headers.get("Content-Type");
+        if (contentType && contentType.includes("application/json") && response.status === 201) {
+            const post = await response.json();
+            return NextResponse.json(post, { status: 201 });
+        }
+        return NextResponse.json({ message: "The request contains errors, such as invalid data, incorrect format, or missing required fields." }, { status: 400 });
+
+    } catch (error) {
+        throw new Error("Erro ao conectar no backend.");
+    }
+}
+`;
+
+// src/templates/routes/update-resource-route.ts
+var updateResourceTemplate = (resourceInSigular, resourceInPlural) => `
+import { cookies } from "next/headers";
+import { NextRequest, NextResponse } from "next/server";
+
+export async function POST(req: NextRequest, context: { params: Promise<{ ${resourceInSigular.toLocaleLowerCase()}Id: string }> }) {
+    const { ${resourceInSigular.toLocaleLowerCase()}Id } = await context.params;
+
+    try {
+        const cookieStore = cookies();
+        const token = (await cookieStore).get("jwt_back");
+        let jwt = !token ? "not found" : token.value;
+
+        const response = await fetch(\`\${process.env.NEXT_PUBLIC_BACKEND_URL}/${resourceInPlural.toLocaleLowerCase()}/\${${resourceInSigular.toLocaleLowerCase()}Id}\`, {
+            method: "PATCH",
+            headers: {
+                Authorization: \`Bearer \${jwt}\`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(await req.json()),
+        });
+
+        if (response.status === 200) {
+            const post = await response.json();
+            return NextResponse.json(post, { status: 200 });
+        }
+        return NextResponse.json({ message: "${resourceInPlural.toLocaleLowerCase()} not exists" }, { status: 404 });
+    } catch (error) {
+        throw new Error("Erro ao conectar no backend.");
+    }
+}
+`;
+
+// src/templates/forms/forgot-form.ts
+var formForgotTemplate = () => `
+"use client";
+
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { toast } from "react-toastify";
+
+type Response = { message: string, statusCode: number };
+export async function sendEmailServerSideProps(email: string): Promise<Response> {
+    try {
+        const response = await fetch(\`\${ process.env.NEXT_PUBLIC_BACKEND_URL }/auth/sendEmail\`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ email }),
+            cache: "no-store",
+        });
+
+        if (response.ok) {
+            return { message: "Email sent successfully.", statusCode: 200 };
+        } else if (response.status === 404) {
+            return { message: "This email address is not registered in the system.", statusCode: 404 };
+        }
+
+        return { message: "Incorrect email format.", statusCode: 400 };
+    } catch {
+        return { message: "The server is not responding.", statusCode: 500 };
+    }
+}
+
+export const FormForgot = () => {
+    const router = useRouter();
+    const [data, setData] = useState<Response>({ statusCode: 0, message: "" });
+
+    const handleSubmit = async (e: React.SyntheticEvent<HTMLFormElement>) => {
+        e.preventDefault();
+
+        const form = e.currentTarget;
+        const emailInput = form.elements.namedItem("email") as HTMLInputElement | null;
+
+        if (!emailInput) {
+            toast.error("Email field not found.");
+            return;
+        }
+
+        const email = emailInput.value;
+
+        const data = await sendEmailServerSideProps(email);
+        setData(data);
+
+        if (data.statusCode !== 200) {
+            toast.error(data.message);
+        } else {
+            router.push("/forgotredef");
+        }
+    };
+
+    return (
+        <div className="w-full max-w-md p-8 space-y-6 bg-white rounded shadow-md">
+            <h2 className="text-2xl font-bold text-center">Forgot Password</h2>
+
+            <form className="space-y-4" onSubmit={handleSubmit}>
+                <label htmlFor="email" className="block text-sm font-medium text-gray-700">
+                    Email
+                </label>
+
+                <input id="email" name="email" type="email" required className="w-full px-3 py-2 mt-1 border rounded shadow-sm focus:outline-none focus:ring focus:border-blue-300"/>
+
+                <button type="submit" className="w-full px-4 py-2 font-bold text-white bg-blue-500 rounded hover:bg-blue-700">
+                    Send
+                </button>
+
+                <div className="mt-3 flex justify-between">
+                    <Link href="/" className="text-sm text-blue-500 hover:underline">
+                        Back to login
+                    </Link>
+                    <Link href="/cadastro" className="text-sm text-blue-500 hover:underline">
+                        Create account
+                    </Link>
+                </div>
+            </form>
+        </div>
+    );
+};
+`;
+
+// src/templates/forms/login-form.ts
+var formLoginTemplate = () => `
+"use client";
+
+import { startTransition } from "react";
+import { signIn, signOut } from "next-auth/react";
+import { useId, useActionState, useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "react-toastify";
+import { usePathname } from "next/navigation";
+import Link from "next/link";
+
+import { hiddenPaths } from "./hidenpath";
+import { ButtonGeneric } from "@/components/ButtonGeneric";
+
+type TypeLoginData = { email: string; password: string; };
+
+export const FormLogin: React.FC = () => {
+  const pathname = usePathname();
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
+
+  const idEmail = useId();
+  const idPassword = useId();
+  const { register, handleSubmit, formState: { errors } } = useForm<TypeLoginData>();
+
+  const [state, setState, isPending] = useActionState(
+    async (prevState: any, data: TypeLoginData) => {
+      try {
+        const response = await signIn("credentials", { redirect: false, ...data, callbackUrl: "/manager" });
+
+        if (response?.status === 401) {
+          toast.error("invalid credentials");
+          return { success: false };
+        }
+
+        if (response?.url) {
+          window.location.href = response.url;
+        }
+
+        return { success: true };
+      } catch (error) {
+        toast.error(
+          error instanceof Error ? error.message : "error authenticating"
+        );
+        return { success: false };
+      }
+    },
+    { success: false }
+  );
+
+  const onSubmitForm = (data: TypeLoginData) => {
+    startTransition(() => { setState(data); });
+  };
+
+  const handleLogout = async () => {
+    await signOut({ callbackUrl: "/" });
+  };
+
+  if (!mounted) {
+    return <div style={{ height: 35 }} />;
+  }
+
+  const isHidden = hiddenPaths.some((path) => pathname.startsWith(path));
+  if (isHidden) { return <ButtonGeneric label="Sair" onClick={handleLogout} />; };
+
+  return (
+    <form onSubmit={handleSubmit(onSubmitForm)} className="w-full flex flex-col items-center gap-3 lg:gap-3">
+      {/* Email */}
+      <div className="flex flex-col lg:flex-row lg:items-center max-h-8.75 gap-2">
+        <label htmlFor={idEmail} className="text-sm font-semibold text-(--text-color)">e-mail:</label>
+        <input id={idEmail} type="text" {...register("email", { required: "Este campo \xE9 obrigat\xF3rio" })}
+          className="min-h-7.5 max-w-30 lg:max-w-30 text-(--text-color) px-3 border border-gray-300 rounded-full outline-none text-sm bg-(--bg-color) caret-(--text-color) text-center transition-all duration-200 focus:border-blue-500 focus:ring-2 focus:ring-blue-200 w-full lg:w-auto"
+        />
+        {errors.email && (
+          <span className="text-red-600 text-sm mt-2">
+            {errors.email.message}
+          </span>
+        )}
+      </div>
+
+      {/* Password */}
+      <div className="flex flex-col lg:flex-row lg:items-center max-h-8.75 gap-2">
+        <label htmlFor={idPassword} className="text-sm font-semibold text-(--text-color)">password:</label>
+        <input id={idPassword} type="password" {...register("password", { required: "Este campo \xE9 obrigat\xF3rio" })}
+          className="min-h-7.5 max-w-30 lg:max-w-30 text-(--text-color) px-3 border border-gray-300 rounded-full outline-none text-sm bg-(--bg-color) caret-(--text-color) text-center transition-all duration-200 focus:border-blue-500 focus:ring-2 focus:ring-blue-200 w-full lg:w-auto"
+        />
+        {errors.password && (
+          <span className="text-red-600 text-sm mt-2">
+            {errors.password.message}
+          </span>
+        )}
+      </div>
+
+      {/* Submit */}
+      <div className="mt-2 lg:mt-0">
+        <ButtonGeneric type="submit" label={isPending ? "Entrando..." : "Entrar"} disabled={isPending} className={\`w-full lg:w-auto justify-center \${isPending ? "opacity-70 cursor-not-allowed" : ""}\`} />
+      </div>
+
+      {/* Forgot password */}
+      <div className="h-full flex flex-col justify-center items-center mt-2 lg:mt-0 text-sm">
+         <Link href="/cadastro" className="text-blue-700 cursor-pointer">cadastre-se</Link>
+        <Link href="/forgotpassword" className="text-blue-700 cursor-pointer">esqueceu sua senha?</Link>
+      </div>
+    </form>
+  );
+};
+`;
+
+// src/templates/forms/redef-form.ts
+var formRedefTemplate = () => `
+"use client";
+
+import { useForm, FormProvider } from 'react-hook-form';
+import { useRouter } from 'next/navigation';
+import { yupResolver } from '@hookform/resolvers/yup';
+import { formSchema } from './formredef-scheme';
+import { InputCustom } from '@/components/Inputs/InputCustom';
+
+type Response = { message: string, statusCode: number };
+interface IFormInputRedem { token: string; password: string; confirpassword: string; };
+export async function sendRedemServerSideProps(data: IFormInputRedem): Promise<Response> {
+    try {
+        const response = await fetch(\`\${process.env.NEXT_PUBLIC_BACKEND_URL}/auth/redefinir\`, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ token: data.token, password: data.password, rePassword: data.confirpassword }),
+        });
+
+        if (response.ok) return { message: "Password reset successfully.", statusCode: 200 } as Response;
+        return { message: "User not found, or invalid token.", statusCode: 404 } as Response;
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        // Erro de rede pode ocorrer nenhum status \xE9 retornado
+        return { message: "The server stopped responding", statusCode: 500 } as Response;
+    }
+};
+
+export const FormRedef = () => {
+  const router = useRouter();
+  const methods = useForm<IFormInputRedem>({ resolver: yupResolver(formSchema) , mode: 'onChange', defaultValues: { token: '', password: '', confirpassword: '' } });
+
+  const onSubmit = async (data: IFormInputRedem) => {
+    const response = await sendRedemServerSideProps(data);
+    if (response.statusCode === 200) {
+      router.push("/login");
+    }
+  };
+
+  return (
+    <FormProvider {...methods}>
+      <form onSubmit={methods.handleSubmit(onSubmit)} className="space-y-4 p-6 bg-white shadow-md rounded-md">
+        <InputCustom name="token" label="C\xF3digo" required={true} />
+        <InputCustom name="password" label="Senha" type="password" required={true} />
+        <InputCustom name="confirpassword" label="Confirme a senha" type="password" required={true} />
+
+        <button type="submit" className="w-full p-2 bg-blue-500 text-white rounded-md hover:bg-blue-600">Send</button>
+      </form>
+    </FormProvider>
+  );
+}
+`;
+
+// src/templates/forms/update-user-form.ts
+var formUpdateUserTemplate = () => `
+"use client";
+
+import { useForm, FormProvider, type Resolver } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { toast } from "react-toastify";
+import { useSession } from "next-auth/react";
+import { updateFormSchema, UpdateFormSchemaType } from "./formupdateuser-scheme";
+import { InputCustom } from "@/components/Inputs/InputCustom";
+import { ButtonGeneric } from "@/components/ButtonGeneric";
+
+export enum TypeUserStatus { ACTIVE = 'ACTIVE', SUSPENDED = 'SUSPENDED', BANNED = 'BANNED' };
+export interface UpdateUserInput {
+  photo?: string; bio?: string; skills?: string[];
+  hourly_rate?: number; score?: number; checked?: boolean; userStatus?: TypeUserStatus;
+}
+export const FormUpdateUser = () => {
+  const [photoFile, setPhotoFile] = useState<File | null>(null);
+  const router = useRouter();
+  const { data: session, update } = useSession();
+
+  const methods = useForm<UpdateFormSchemaType>({
+    resolver: yupResolver(updateFormSchema) as Resolver<UpdateFormSchemaType>, mode: "onChange",
+    defaultValues: { photo: "", bio: "", skills: "", hourly_rate: null },
+  });
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0] ?? null;
+    setPhotoFile(file);
+  };
+
+  const handleSubmitUpdate = async (data: UpdateFormSchemaType) => {
+    try {
+      const payload: UpdateUserInput = {
+        photo: photoFile?.name ?? undefined,
+        bio: data.bio ?? undefined,
+        skills: data.skills?.split(","),
+        hourly_rate: data.hourly_rate ?? undefined,
+        score: undefined,
+        checked: undefined,
+        userStatus: undefined,
+      };
+
+      const response = await fetch(\`\${process.env.NEXT_PUBLIC_URL}/api/users/update\`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        toast.error(errorData.message || "Erro ao atualizar informa\xE7\xF5es do usu\xE1rio");
+        return;
+      }
+      const usersession = await response.json();
+      // \u{1F539} Upload da foto (caso exista)
+      if (photoFile && usersession) {
+        const formData = new FormData();
+        formData.append("photo", photoFile, photoFile.name);
+        const uploadResp = await fetch(\`\${process.env.NEXT_PUBLIC_URL}/api/users/photo\`, { method: "POST", body: formData });
+        if (uploadResp.ok) {
+          const userAtualizado = await uploadResp.json();
+          const newSession = await update({ user: { ...session?.user, image: userAtualizado.photo, } });
+          if (newSession) {
+            toast.success("Dados do usu\xE1rio atualizados com sucesso!");
+          }
+        } else {
+          toast.error("Erro ao enviar a foto");
+        }
+      }
+      router.refresh();
+      router.push("/manager");
+    } catch (error) {
+      console.error(error);
+      toast.error("Erro de comunica\xE7\xE3o com o servidor");
+    }
+  };
+
+  return (
+    <FormProvider {...methods}>
+      <form onSubmit={methods.handleSubmit(handleSubmitUpdate)}
+        className="flex flex-col gap-6 sm:p-6 lg:p-8 w-full bg-white/80 backdrop-blur-md rounded-3xl shadow-[0_8px_30px_rgb(0,0,0,0.12)] border border-gray-100 max-w-[90%] mx-auto"
+      >
+        {/* Foto */}
+        <div>
+          <label className="block text-sm font-medium text-gray-700">Foto do usu\xE1rio</label>
+          <input type="file" accept="image/*" onChange={handleFileChange} className="mt-2 border border-gray-300 rounded-lg p-2 w-full" />
+          {photoFile && <p className="text-sm text-gray-600 mt-1">{photoFile.name}</p>}
+        </div>
+
+        {/* Bio */}
+        <InputCustom name="bio" label="Biografia" type="text" />
+
+        {/* Skills */}
+        <InputCustom name="skills" label="Habilidades (separadas por v\xEDrgula)" type="text" />
+
+        {/* Hourly Rate */}
+        <InputCustom name="hourly_rate" label="Valor por hora" type="number" />
+
+        {/* Bot\xE3o */}
+        <ButtonGeneric type="submit" label="Atualizar Usu\xE1rio" />
+      </form>
+    </FormProvider>
+  );
+};
+`;
+
+// src/templates/forms/register-form.ts
+var formRegisterTemplate = () => `
+"use client";
+
+import { useForm, FormProvider } from "react-hook-form";
+import { useRouter } from "next/navigation";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { formSchema, FormSchemaType } from "./formregister-scheme";
+import { toast } from "react-toastify";
+import { InputCustom } from "@/components/Inputs/InputCustom";
+import { ButtonGeneric } from "@/components/ButtonGeneric";
+
+export const FormRegister = () => {
+  const router = useRouter();
+  const methods = useForm<FormSchemaType>({
+    resolver: yupResolver(formSchema), mode: "onChange",
+    defaultValues: { name: "", email: "", cpf: "", dateOfBirth: new Date(), password: "", repeatPassword: "", phone: "", country: "", state: "", city: "", address: "" },
+  });
+
+  const handlesubmitRegister = async (data: FormSchemaType) => {
+    try {
+      const response = await fetch(\`\${process.env.NEXT_PUBLIC_URL}/api/users\`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+      });
+
+      if (response && response.status === 201) {
+        toast.success("User created successfully.");
+        router.push("/");
+      } else {
+        toast.error(response.status === 400 ? "Email already exists in the application, proceed to password reset" : "Error registering");
+      }
+    } catch (error) {
+      throw new Error("There was a communication.");
+    }
+  };
+
+  return (
+    <FormProvider {...methods}>
+      <form onSubmit={methods.handleSubmit(handlesubmitRegister)} className="flex flex-col gap-4 p-6 bg-white rounded-md w-full max-w-[80%] mx-auto">
+        {/* Linha 1 */}
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <InputCustom name="name" label="Nome completo" required />
+          <InputCustom name="email" label="Email" type="email" required />
+        </div>
+
+        {/* Linha 2 */}
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <InputCustom name="cpf" label="CPF" required />
+          <InputCustom name="dateOfBirth" label="Data de nascimento" type="date" asDate required />
+          <InputCustom name="phone" label="Telefone" required />
+        </div>
+
+        {/* Linha 3 */}
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+          <InputCustom name="country" label="Pa\xEDs" required />
+          <InputCustom name="state" label="Estado" required />
+          <InputCustom name="city" label="Cidade" required />
+        </div>
+
+        {/* Linha 4 */}
+        <InputCustom name="address" label="Endere\xE7o" required />
+
+        {/* Linha 5 - Senhas */}
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <InputCustom name="password" label="Senha" type="password" required />
+          <InputCustom name="repeatPassword" label="Confirme sua senha" type="password" required />
+        </div>
+
+        {/* Bot\xE3o */}
+        <div className="flex justify-center mt-4">
+          <ButtonGeneric label="Registrar" />
+        </div>
+      </form>
+    </FormProvider>
+  );
+};
+
+`;
+
+// src/templates/forms/login-wrapper-form.ts
+var formLoginWrapperTemplate = () => `
+"use client";
+
+import { useState } from "react";
+import { usePathname } from "next/navigation";
+import { motion, AnimatePresence } from "framer-motion";
+import { FormLogin } from ".";
+import { XIcon } from "lucide-react";
+import { hiddenPaths } from "./hidenpath";
+import { ButtonGeneric } from "@/components/ButtonGeneric";
+
+export const FormLoginWrapper = () => {
+  const pathname = usePathname();
+  const [open, setOpen] = useState(false);
+
+  const isHidden = hiddenPaths.some((path) => pathname.startsWith(path));
+
+  // If the route is protected \u2192 only the FormLogin itself is rendered (which displays the "Log Out" button).
+  if (isHidden) {
+    return <FormLogin />;
+  }
+
+  return (
+    <>
+      {/* Mobile & Tablets (<lg): displays normal form */}
+      <div className="bg-(--bg-color) block md:hidden">
+        <FormLogin />
+      </div>
+
+      {/* Desktop (lg:): button + modal */}
+      <div className="hidden md:flex">
+        <ButtonGeneric label="Login" onClick={() => setOpen(true)} />
+      </div>
+
+      {/* MODAL */}
+      <AnimatePresence>
+        {open && (
+          <motion.div className="fixed inset-0 bg-black/40 backdrop-blur-sm flex items-center justify-center z-999" initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}>
+            <motion.div className="bg-(--bg-color) rounded-2xl p-6 w-105 shadow-xl relative" initial={{ scale: 0.8, opacity: 0 }} animate={{ scale: 1, opacity: 1 }} exit={{ scale: 0.8, opacity: 0 }} transition={{ type: "spring", stiffness: 120 }}>
+              {/* Bot\xE3o fechar */}
+              <button onClick={() => setOpen(false)} className="absolute right-4 top-4 text-gray-600 hover:text-black text-xl">
+                <XIcon />
+              </button>
+
+              <h2 className="text-lg font-semibold mb-4">Login</h2>
+
+              {/* Form within the modal */}
+              <FormLogin />
+            </motion.div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+    </>
+  );
+};
+
+`;
+
+// src/utils/fs.ts
+import fs from "fs";
+import path from "path";
+var createDir = (dirPath) => {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  ;
+};
+var createFile = (filePath, content) => {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, content.trimStart());
+  }
+};
+function pathExists(p) {
+  return fs.existsSync(p);
+}
+var moveFile = (fromPath, toPath) => {
+  if (fs.existsSync(fromPath)) {
+    const toDir = path.dirname(toPath);
+    if (!fs.existsSync(toDir)) {
+      fs.mkdirSync(toDir, { recursive: true });
+    }
+    fs.renameSync(fromPath, toPath);
+  }
+};
+
+// src/utils/string.ts
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/pages/update-page.ts
+var updatePageTemplate = (resourceInSingular, resourceInPlural) => `
+  import { authOptions } from "@/app/api/auth/[...nextauth]/route";
+  import { FormEdit${resourceInSingular} } from "@/forms/${resourceInPlural.toLocaleLowerCase()}";
+  //import { ${resourceInSingular} } from "@/utils/models/${resourceInPlural.toLocaleLowerCase()}";
+  import { Session } from "@/utils/route";
+  import { getServerSession } from "next-auth";
+  import { redirect } from "next/navigation";
+
+  type ${resourceInSingular} = {}
+  interface PageProps { params: { ${resourceInSingular.toLocaleLowerCase()}Id: string; }; };
+
+  async function get${resourceInSingular}ById(${resourceInSingular.toLocaleLowerCase()}Id: string, token: string): Promise< ${resourceInSingular} | null> {
+    try {
+      const response = await fetch(\`\${process.env.NEXT_BACKEND_URL}/${resourceInPlural.toLocaleLowerCase()}/\${${resourceInSingular.toLocaleLowerCase()}Id}\`,
+        {
+          method: "GET",
+          cache: "no-store",
+          headers: {
+            Authorization: \`Bearer \${token}\`,
+          },
+        }
+      );
+      if (!response.ok) { return null; };
+      const ${resourceInSingular.toLocaleLowerCase()}: ${resourceInSingular} = await response.json();
+      return ${resourceInSingular.toLocaleLowerCase()};
+    } catch (error) {
+      console.error("Erro ao buscar ${resourceInSingular.toLocaleLowerCase()}:", error);
+      return null;
+    }
+  };
+
+  export default async function ${resourceInSingular}EditPage({ params }: PageProps) {
+    const { ${resourceInSingular.toLocaleLowerCase()}Id } = await params;
+    const session: Session | null = await getServerSession(authOptions);
+    if (!session) redirect("/");
+    const ${resourceInSingular.toLocaleLowerCase()}: ${resourceInSingular} | null = await get${resourceInSingular}ById(${resourceInSingular.toLocaleLowerCase()}Id, session.accessToken);
+    return (
+      <div className="w-full min-h-screen bg-[--bg-section-100] p-10 transition-colors duration-500">
+        <div className="max-w-3xl mx-auto flex flex-col gap-8">
+
+          {${resourceInSingular.toLocaleLowerCase()} ? (
+            <>
+              {/* Informa\xE7\xF5es do post */}
+              <section className="bg-white/70 dark:bg-black/20 rounded-xl p-6 shadow">
+                <h1 className="text-2xl font-semibold">Editar ${resourceInSingular}</h1>
+                <p className="text-sm opacity-70 mt-1">
+                  Este ${resourceInSingular} foi \u2022 Criado em {${resourceInSingular.toLocaleLowerCase()}.createdAt.toString()}
+                </p>
+              </section>
+
+              {/* Formul\xE1rio */}
+              <FormEdit${resourceInSingular} ${resourceInSingular.toLowerCase()}={${resourceInSingular.toLocaleLowerCase()}} />
+            </>
+          ) : (
+            <section className="bg-white/70 dark:bg-black/20 rounded-xl p-6 shadow text-center">
+              <h1 className="text-xl font-semibold">
+                Post n\xE3o encontrado
+              </h1>
+              <p className="text-sm opacity-70 mt-2">
+                O ${resourceInSingular} que voc\xEA est\xE1 tentando editar n\xE3o existe ou foi removido.
+              </p>
+            </section>
+          )}
+
+        </div>
+      </div>
+    );
+  };
+
+`;
+
+// src/templates/pages/delete-page.ts
+var deletePageTemplate = (resourceInSingular, resourceInPlural) => `
+import { FormDeleteResource } from "@/forms/shared";
+
+interface PageProps { params: { ${resourceInSingular.toLocaleLowerCase()}Id: string; }; };
+export default async function ${resourceInSingular}DeletePage({ params }: PageProps) {
+  const { ${resourceInSingular.toLocaleLowerCase()}Id } = await params;
+
+  return <div className="w-full min-h-screen flex flex-col bg-[--bg-section-100] p-10 transition-colors duration-500">
+    <h2 className="text-center">Tem certeza que vc quer deletar esse ${resourceInSingular}?</h2>
+    <FormDeleteResource resource={"${resourceInPlural.toLocaleLowerCase()}"} resourceId={${resourceInSingular.toLocaleLowerCase()}Id} />
+  </div>;
+}
+`;
+
+// src/utils/services/install-dependences.service.ts
+import { execSync } from "child_process";
+
+// src/utils/guards/next-verify.guard.ts
+import fs2 from "fs";
+import path2 from "path";
+function nextProjectGuardSimple() {
+  const cwd = process.cwd();
+  const pkgPath = path2.join(cwd, "package.json");
+  if (!fs2.existsSync(pkgPath)) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mNenhum package.json encontrado neste diret\xF3rio.");
+    process.exit(1);
+  }
+  const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+  const hasNext = pkg.dependencies?.next || pkg.devDependencies?.next;
+  if (!hasNext) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mExecute dentro de um projeto Next.js");
+    process.exit(1);
+  }
+}
+
+// src/utils/guards/dependency.guard.ts
+import fs3 from "fs";
+import path3 from "path";
+function hasDependency(pkgName) {
+  const cwd = process.cwd();
+  const pkgPath = path3.join(cwd, "package.json");
+  if (!fs3.existsSync(pkgPath)) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mNenhum package.json encontrado.");
+    process.exit(1);
+  }
+  const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+  return Boolean(
+    pkg.dependencies?.[pkgName] || pkg.devDependencies?.[pkgName] || pkg.peerDependencies?.[pkgName]
+  );
+}
+
+// src/utils/services/install-dependences.service.ts
+var DependencyInstaller = class _DependencyInstaller {
+  constructor() {
+    this.hasInstalled = false;
+  }
+  static getInstance() {
+    if (!_DependencyInstaller.instance) {
+      _DependencyInstaller.instance = new _DependencyInstaller();
+    }
+    return _DependencyInstaller.instance;
+  }
+  async install() {
+    if (this.hasInstalled || hasDependency("lucide-react")) return;
+    this.hasInstalled = true;
+    try {
+      execSync(`
+                npm install lucide-react &&
+                npm install clsx
+            `, { stdio: "inherit" });
+      console.log("Depend\xEAncias instaladas com sucesso!");
+    } catch (error) {
+      console.error("Falha ao instalar depend\xEAncias:", error);
+    }
+    ;
+  }
+};
+
+// src/builders/core/next-accelerate-builder.ts
+import pluralize from "pluralize";
+
+// src/utils/services/git.service.ts
+import { execSync as execSync2 } from "child_process";
+function gitCommit(message) {
+  if (!message) return;
+  const safeMessage = String.raw`${message.replace(/(["`$\\])/g, "\\$1")}`;
+  try {
+    execSync2("git add .", { stdio: "ignore" });
+    execSync2(`git commit -m "${safeMessage}"`, { stdio: "ignore" });
+  } catch (error) {
+    console.error("Failed to commit changes:", error);
+  }
+}
+
+// src/builders/core/next-accelerate-builder.ts
+var NextAccelerateBuilder = class {
+  constructor(inputName, options) {
+    this.inputName = inputName;
+    this.options = options;
+    this.basePath = process.cwd();
+    this.resource = pluralize(inputName.toLowerCase());
+    this.singular = pluralize.singular(this.resource);
+  }
+  createCommit(message) {
+    if (!this.options?.git) return;
+    gitCommit(message);
+  }
+  build() {
+    if (!this.options?.git) return;
+    console.log("commits made successfully \u2728");
+  }
+};
+
+// src/builders/resource-builder.ts
+var NextResourceBuilder = class extends NextAccelerateBuilder {
+  constructor(inputName, options) {
+    super(inputName, options);
+  }
+  // required for components only
+  installDependencesRequired() {
+    DependencyInstaller.getInstance().install();
+    return this;
+  }
+  setBasePath() {
+    this.basePath = path4.join(process.cwd(), "src/app/(privates)", this.resource);
+    createDir(this.basePath);
+    return this;
+  }
+  setBasePathForComponents() {
+    this.basePath = path4.join(process.cwd(), "src/components");
+    createDir(this.basePath);
+    return this;
+  }
+  createComponentInputCustom() {
+    const componentPath = path4.join(this.basePath, "Inputs/InputCustom");
+    createDir(componentPath);
+    createFile(path4.join(componentPath, "index.tsx"), inputTemplate());
+    if (this.options?.test) {
+      createFile(path4.join(componentPath, "InputCustom.spec.tsx"), inputTestUnitTemplate());
+      createFile(path4.join(componentPath, "renderWithForm.tsx"), inputFormHelperTestUnitTemplate());
+    }
+    ;
+    if (this.options?.git) this.createCommit(`feat(input): add input custom component`);
+    return this;
+  }
+  createListPage() {
+    createFile(path4.join(this.basePath, "page.tsx"), listPageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    return this;
+  }
+  createDetailPage() {
+    const detailDir = path4.join(this.basePath, `[${this.singular}Id]`);
+    createDir(detailDir);
+    createFile(path4.join(detailDir, "page.tsx"), detailPageTemplate(capitalize(this.singular)));
+    const editDir = path4.join(detailDir, "edit");
+    createDir(editDir);
+    createFile(path4.join(editDir, "page.tsx"), updatePageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    const deleteDir = path4.join(detailDir, "delete");
+    createDir(deleteDir);
+    createFile(path4.join(deleteDir, "page.tsx"), deletePageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    this.createCommit(`feat(${this.resource}): add all pages for detail view`);
+    return this;
+  }
+  createNewPage() {
+    const dir = path4.join(this.basePath, "new");
+    createDir(dir);
+    createFile(path4.join(dir, "page.tsx"), newPageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    return this;
+  }
+};
+
+// src/commands/create-resource.ts
+function createResource(inputName, options) {
+  nextProjectGuardSimple();
+  if (!inputName) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mPlease provide the name of the resource.");
+    process.exit(1);
+  }
+  const builder = new NextResourceBuilder(inputName, options);
+  builder.setBasePath().createListPage().createDetailPage().createNewPage().build();
+  console.log(`Resource "${inputName}" created \x1B[32m\u2714 Success\x1B[0m`);
+}
+function createComponents(options) {
+  nextProjectGuardSimple();
+  const builder = new NextResourceBuilder("default", options);
+  builder.installDependencesRequired().setBasePathForComponents().createComponentInputCustom().build();
+  console.log(`Resource "components" created \x1B[32m\u2714 Success\x1B[0m`);
+}
+
+// src/builders/resource-form-builder.ts
+import path5 from "path";
+
+// src/utils/services/install-dependences-form.service.ts
+import { execSync as execSync3 } from "child_process";
+var DependencyFormInstaller = class _DependencyFormInstaller {
+  constructor() {
+    this.hasInstalled = false;
+  }
+  static getInstance() {
+    if (!_DependencyFormInstaller.instance) {
+      _DependencyFormInstaller.instance = new _DependencyFormInstaller();
+    }
+    return _DependencyFormInstaller.instance;
+  }
+  async install() {
+    if (this.hasInstalled || hasDependency("react-hook-form")) return;
+    this.hasInstalled = true;
+    try {
+      execSync3(`
+                npm install react-hook-form &&
+                npm install yup @hookform/resolvers &&
+                npm install -D @types/yup &&
+                npm install react-toastify
+            `, { stdio: "inherit" });
+      console.log("Depend\xEAncias instaladas com sucesso!");
+    } catch (error) {
+      console.error("Falha ao instalar depend\xEAncias:", error);
+    }
+    ;
+  }
+};
+
+// src/templates/components/footer-comp.ts
+var footerTemplate = () => `
+export const Footer: React.FC = () => {
+  return (
+    <footer className="bg-(--brand-footer) font-sans">
+      <div className="container px-6 py-12 mx-auto">
+        <div className="grid grid-cols-1 gap-6 sm:grid-cols-2 sm:gap-y-10 lg:grid-cols-4">
+          <div className="sm:col-span-2">
+            <h1 className="max-w-lg text-xl font-semibold tracking-tight text-gray-800 xl:text-2xl dark:text-white">Subscribe our newsletter to get an update.</h1>
+
+            <div className="flex flex-col mx-auto mt-6 space-y-3 md:space-y-0 md:flex-row">
+              <input id="email" type="text" className="px-4 py-2 text-gray-700  border rounded-md bg-(--brand-footer) dark:text-gray-300 dark:border-gray-600 focus:border-blue-400 dark:focus:border-blue-300 focus:outline-none focus:ring focus:ring-opacity-40 focus:ring-blue-300" placeholder="Email Address" />
+
+              <button className="w-full px-6 py-2.5 text-sm font-medium tracking-wider text-white transition-colors duration-300 transform md:w-auto md:mx-4 focus:outline-none bg-gray-800 rounded-lg hover:bg-gray-700 focus:ring focus:ring-gray-300 focus:ring-opacity-80">
+                Subscribe
+              </button>
+            </div>
+          </div>
+
+          <div>
+            <p className="font-semibold text-gray-800 dark:text-white">Quick Link</p>
+
+            <div className="flex flex-col items-start mt-5 space-y-2">
+              <p className="text-gray-600 transition-colors duration-300 dark:text-gray-300 dark:hover:text-blue-400 hover:underline hover:cursor-pointer hover:text-blue-500">Home</p>
+              <p className="text-gray-600 transition-colors duration-300 dark:text-gray-300 dark:hover:text-blue-400 hover:underline hover:cursor-pointer hover:text-blue-500">Who We Are</p>
+              <p className="text-gray-600 transition-colors duration-300 dark:text-gray-300 dark:hover:text-blue-400 hover:underline hover:cursor-pointer hover:text-blue-500">Our Philosophy</p>
+            </div>
+          </div>
+
+          <div>
+            <p className="font-semibold text-gray-800 dark:text-white">Industries</p>
+
+            <div className="flex flex-col items-start mt-5 space-y-2">
+              <p className="text-gray-600 transition-colors duration-300 dark:text-gray-300 dark:hover:text-blue-400 hover:underline hover:cursor-pointer hover:text-blue-500">Retail & E-Commerce</p>
+              <p className="text-gray-600 transition-colors duration-300 dark:text-gray-300 dark:hover:text-blue-400 hover:underline hover:cursor-pointer hover:text-blue-500">Information Technology</p>
+              <p className="text-gray-600 transition-colors duration-300 dark:text-gray-300 dark:hover:text-blue-400 hover:underline hover:cursor-pointer hover:text-blue-500">Finance & Insurance</p>
+            </div>
+          </div>
+        </div>
+
+        <hr className="my-6 border-gray-200 md:my-8 dark:border-gray-700 h-2" />
+
+        <div className="sm:flex sm:items-center sm:justify-between">
+          <div className="flex flex-1 gap-2 hover:cursor-pointer">
+            <img src="https://www.svgrepo.com/show/303139/google-play-badge-logo.svg" width="130" height="110" alt="" />
+            <img src="https://www.svgrepo.com/show/303128/download-on-the-app-store-apple-logo.svg" width="130" height="110" alt="" />
+          </div>
+
+          <div className="flex gap-2 hover:cursor-pointer">
+            <img src="https://www.svgrepo.com/show/303114/facebook-3-logo.svg" width="30" height="30" alt="fb" />
+            <img src="https://www.svgrepo.com/show/303145/instagram-2-1-logo.svg" width="30" height="30" alt="inst" />
+            <img src="https://www.svgrepo.com/show/94698/github.svg" className="" width="30" height="30" alt="gt" />
+            <img src="https://www.svgrepo.com/show/22037/path.svg" width="30" height="30" alt="pn" />
+            <img src="https://www.svgrepo.com/show/28145/linkedin.svg" width="30" height="30" alt="in" />
+          </div>
+        </div>
+        <p className="font-sans p-8 text-start md:text-center md:text-lg md:p-4">
+         \xA9 2025 Template Deloped by <a href="https://github.com/brito-response" target="_blank" rel="noopener noreferrer">Neto.</a></p>
+      </div>
+    </footer>
+  );
+};
+
+`;
+
+// src/templates/components/menu-aside-comp.ts
+var menuAsideTemplate = () => `
+"use client";
+
+import { AlignJustifyIcon, FileEditIcon, FolderTreeIcon, HouseIcon, MessageCircleIcon, SettingsIcon, UserIcon, WalletIcon } from "lucide-react";
+import Link from "next/link";
+import { ReactElement, useState } from "react";
+import { useMenu } from "@/contexts/manager-context";
+
+type NavItem = { icon: ReactElement; title: string; url: string; };
+
+export const MenuAside: React.FC = () => {
+  const { menuActive, setMenuActive } = useMenu();
+  const [hoveredIndex, setHoveredIndex] = useState<number | null>(null);
+
+  const navItems: NavItem[] = [
+    { icon: <HouseIcon size={24} />, title: "Manager", url: "/manager" },
+    { icon: <FileEditIcon size={24} />, title: "Posts", url: "/posts" },
+    { icon: <FolderTreeIcon size={24} />, title: "Categorias", url: "/categories" },
+    { icon: <MessageCircleIcon size={24} />, title: "Mensagens", url: "/messages" },
+    { icon: <UserIcon size={24} />, title: "Portifolio", url: "/portifolios" },
+    { icon: <SettingsIcon size={24} />, title: "Setting", url: "/settings" },
+  ];
+
+  return (
+    <aside className={\`\${menuActive ? "w-20" : "w-72"} h-full bg-[#202020] border-r-8 border-[#0489a1] flex flex-col transition-all duration-100 overflow-hidden z-10\`}>
+      {/* Bot\xE3o toggle */}
+      <button type="button" onClick={() => setMenuActive(!menuActive)} className="w-14 h-14 flex justify-center items-center text-white hover:bg-[#0489a1] transition-colors duration-300 mt-3 rounded-lg">
+        <AlignJustifyIcon size={28} />
+      </button>
+
+      {/* Navega\xE7\xE3o */}
+      <ul className="flex flex-col mt-4 gap-2 flex-1">
+        {navItems.map((item: NavItem, index) => (
+          <li key={index} onMouseEnter={() => setHoveredIndex(index)} onMouseLeave={() => setHoveredIndex(null)} className={\`relative rounded-l-3xl transition-all duration-300 \${hoveredIndex === index ? "hover:bg-[#0489a1]" : ""}\`}>
+            <Link href={item.url} className={\`flex items-center text-white py-3 transition-colors duration-200 \${hoveredIndex === index ? "text-[#0489a1] " : "text-white"}\`}>
+              <span className="flex justify-center items-center min-w-15 h-15">
+                {item.icon}
+              </span>
+              <span className={\`whitespace-nowrap text-base font-medium transition-opacity duration-300 \${menuActive ? "opacity-0 pointer-events-none" : "opacity-100"}\`}>
+                {item.title}
+              </span>
+            </Link>
+          </li>
+        ))}
+      </ul>
+    </aside>
+  );
+};`;
+
+// src/templates/components/header-comp.ts
+var headerTemplate = () => `
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { Menu, X } from "lucide-react";
+// import { ToggleButtonTheme } from "../../Buttons/ToggleButtonTheme";
+// import { NavBar } from "../../Navbar";
+// import { Logo } from "../../Logo";
+import { FormLoginWrapper } from "@/forms/users/FormLogin/formwraper";
+
+export const Header: React.FC = () => {
+  const [open, setOpen] = useState(false);
+  const [isMobile, setIsMobile] = useState(false);
+  const panelRef = useRef<HTMLDivElement | null>(null);
+
+  useEffect(() => {
+    const checkSize = () => setIsMobile(window.innerWidth < 1024);
+    checkSize();
+    window.addEventListener("resize", checkSize);
+    return () => window.removeEventListener("resize", checkSize);
+  }, []);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setOpen(false);
+    };
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, []);
+
+  useEffect(() => {
+    const onClick = (e: MouseEvent) => {
+      if (!open) return;
+      if (panelRef.current && !panelRef.current.contains(e.target as Node)) {
+        setOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", onClick);
+    return () => document.removeEventListener("mousedown", onClick);
+  }, [open]);
+
+  return (
+    <header className="w-full px-5 py-1.5 bg-(--bg-header-color) text-(--text-color) shadow-[rgba(0,0,0,0.25)_0px_54px_55px,rgba(0,0,0,0.12)_0px_-12px_30px,rgba(0,0,0,0.12)_0px_4px_6px,rgba(0,0,0,0.17)_0px_12px_13px,rgba(0,0,0,0.09)_0px_-3px_5px] relative z-40">
+      <div className="flex items-center justify-between lg:py-2">
+        {/* Logo */}
+        <div className="flex items-center px-[5%] mr-auto">
+          {/* <Logo /> */}
+        </div>
+
+        <div className="flex items-center justify-between gap-5">
+          {/* Menu Desktop */}
+          <nav className="hidden lg:block">
+            {/* <NavBar onLinkClick={() => setOpen(false)} /> */}
+          </nav>
+
+          {/* \xC1rea Desktop: tema + login */}
+          <div className="hidden lg:flex items-center gap-3">
+            {/* <ToggleButtonTheme /> */}
+           <FormLoginWrapper />
+          </div>
+
+          {/* Bot\xE3o Mobile */}
+          {isMobile && (
+            <button className="inline-flex items-center justify-center p-1.5 rounded-lg bg-transparent border-none cursor-pointer"
+              onClick={() => setOpen((s) => !s)} aria-expanded={open} aria-label={open ? "Fechar menu" : "Abrir menu"}>
+              {open ? <X size={22} /> : <Menu size={22} />}
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* Backdrop Mobile */}
+      {open && isMobile && (
+        <div className="fixed inset-0 bg-black/35 z-49" onClick={() => setOpen(false)}/>
+      )}
+
+      {/* Painel Mobile */}
+      {isMobile && (
+        <aside className={\`fixed top-0 right-0 h-screen w-[85%] max-w-90 bg-(--bg-color) shadow-[-8px_0_30px_rgba(0,0,0,0.15)] z-50 overflow-y-auto transition-all duration-300 ease-in-out \${open ? "translate-x-0" : "translate-x-full"}\`}
+          role="dialog" aria-hidden={!open} ref={panelRef}>
+          <div className="flex flex-col gap-5 p-5 min-h-screen">
+            {/* <NavBar isMobile onLinkClick={() => setOpen(false)} /> */}
+            <div className="mt-[10%] flex flex-col justify-center items-center">
+              {/* <ToggleButtonTheme /> */}
+             <FormLoginWrapper />
+            </div>
+          </div>
+        </aside>
+      )}
+    </header>
+  );
+};
+`;
+
+// src/templates/components/button-comp.ts
+var buttonGenericTemplate = () => `
+"use client";
+
+import React from "react";
+
+type ButtonGenericProps = {
+    label: string;
+    type?: "reset" | "submit" | "button";
+} & React.ComponentProps<"button">;
+
+export const ButtonGeneric: React.FC<ButtonGenericProps> = ({
+    label,
+    type = "submit",
+    className = "",
+    ...props
+}) => {
+    return (
+        <button
+            type={type}
+            className={\`max-h-7 px-6 py-1 bg-(--brand-300) text-white font-bold text-md rounded-md flex items-center justify-center cursor-pointer transition-colors duration-200 ease-in-out hover:bg-(--brand-400) lg:w-auto w-full lg:mt-0 \${className}\`}
+            {...props}
+        >
+            {label}
+        </button>
+    );
+};
+`;
+var buttonGenericTemplateUnitTest = () => `
+
+`;
+
+// src/builders/resource-form-builder.ts
+var NextResourceFormBuilder = class extends NextAccelerateBuilder {
+  constructor(inputName, options) {
+    super(inputName, options);
+  }
+  installDependencesRequired() {
+    DependencyFormInstaller.getInstance().install();
+    return this;
+  }
+  setBasePathForForm() {
+    this.basePath = path5.join(process.cwd(), "src/forms");
+    createDir(this.basePath);
+    return this;
+  }
+  setBasePathForComponents() {
+    this.basePath = path5.join(process.cwd(), "src/components");
+    createDir(this.basePath);
+    return this;
+  }
+  createButtonComponentForUseInForm() {
+    this.basePath = path5.join(process.cwd(), "src/components/ButtonGeneric");
+    createDir(this.basePath);
+    createFile(path5.join(this.basePath, "index.tsx"), buttonGenericTemplate());
+    if (this.options?.test) createFile(path5.join(this.basePath, "ButtonGeneric.spec.tsx"), buttonGenericTemplateUnitTest());
+    return this;
+  }
+  createCrudForm() {
+    this.basePath = path5.join(process.cwd(), "src/forms");
+    const sharedPath = path5.join(this.basePath, "shared");
+    const deletePath = path5.join(sharedPath, "FormDelete");
+    if (!pathExists(deletePath)) {
+      createDir(sharedPath);
+      createDir(deletePath);
+      createFile(path5.join(deletePath, "index.tsx"), formDeleteTemplate(capitalize(this.singular), capitalize(this.resource)));
+      createFile(path5.join(sharedPath, "index.ts"), `export { FormDeleteResource } from "./FormDelete";
+`);
+    }
+    const resourcePath = path5.join(this.basePath, this.resource);
+    createDir(resourcePath);
+    const formNewPath = path5.join(resourcePath, "FormNew");
+    createDir(formNewPath);
+    createFile(path5.join(formNewPath, "index.tsx"), formCreateTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path5.join(formNewPath, "form-scheme.ts"), formSchemeCreateTemplate());
+    const formEditPath = path5.join(resourcePath, "FormEdit");
+    createDir(formEditPath);
+    createFile(path5.join(formEditPath, "index.tsx"), formUpdateTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path5.join(formEditPath, "form-scheme.ts"), formSchemeUpdateTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path5.join(resourcePath, "index.ts"), `export { FormNew${capitalize(this.singular)} } from "./FormNew";
+ export { FormEdit${capitalize(this.singular)} } from "./FormEdit";`);
+    if (this.options?.git) this.createCommit(`feat(${this.resource}): created crud form components`);
+    return this;
+  }
+};
+
+// src/commands/create-form-resource.ts
+function createFormForResource(inputName, options) {
+  nextProjectGuardSimple();
+  if (!inputName) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mPlease provide the resource name.");
+    process.exit(1);
+  }
+  const builder = new NextResourceFormBuilder(inputName, options);
+  builder.setBasePathForForm().setBasePathForComponents().createButtonComponentForUseInForm().createCrudForm().installDependencesRequired().build();
+  console.log(`Form for the resource "${inputName}" created \x1B[32m\u2714 Success\x1B[0m`);
+}
+
+// src/builders/next-auth-builder.ts
+import path6 from "path";
+
+// src/templates/forms/schems/login-form-scheme.ts
+var formSchemeLoginTemplate = () => `
+import * as yup from 'yup';
+
+export const formSchema = yup.object().shape({
+  email: yup.string().required('O email \xE9 obrigat\xF3rio').email('Digite um email v\xE1lido'),
+  password: yup.string().required('A senha \xE9 obrigat\xF3ria').min(6, 'A senha deve ter pelo menos 6 caracteres'),
+});
+
+export type FormSchemaType = yup.InferType<typeof formSchema>;
+
+
+`;
+
+// src/templates/forms/schems/redef-form-scheme.ts
+var formSchemeRedefTemplate = () => `
+import * as yup from 'yup';
+
+export const formSchema = yup.object().shape({
+  token: yup.string().required('O c\xF3digo \xE9 obrigat\xF3rio'),
+  password: yup.string().required('A senha \xE9 obrigat\xF3ria').min(8, 'A senha deve ter pelo menos 8 caracteres'),
+  confirpassword: yup.string().required('A confirma\xE7\xE3o de senha \xE9 obrigat\xF3ria').oneOf([yup.ref('password')], 'As senhas devem ser iguais'),
+});
+
+export type FormSchemaType = yup.InferType<typeof formSchema>;
+
+`;
+
+// src/templates/forms/schems/register-form-scheme.ts
+var formSchemeRegisterTemplate = () => `
+import * as yup from "yup";
+
+export const formSchema = yup.object({
+  name: yup.string().required("O nome \xE9 obrigat\xF3rio").min(3, "O nome deve ter pelo menos 3 caracteres"),
+  email: yup.string().required("O email \xE9 obrigat\xF3rio").email("Digite um email v\xE1lido"),
+  cpf: yup.string().required("O CPF \xE9 obrigat\xF3rio").matches(/^d{11}$/, "O CPF deve conter 11 d\xEDgitos"),
+  dateOfBirth: yup.date().required("A data \xE9 obrigat\xF3ria").max(new Date(), "A data de aniversario \xE9 obrigatoria"),
+  password: yup.string().required("A senha \xE9 obrigat\xF3ria").min(6, "A senha deve ter pelo menos 6 caracteres"),
+  repeatPassword: yup.string().required("A confirma\xE7\xE3o de senha \xE9 obrigat\xF3ria").oneOf([yup.ref("password")], "As senhas devem ser iguais"),
+  phone: yup.string().required("O telefone \xE9 obrigat\xF3rio").matches(/^+?d{10,15}$/, "N\xFAmero de telefone inv\xE1lido"),
+  country: yup.string().required("O pa\xEDs \xE9 obrigat\xF3rio"),
+  state: yup.string().required("O estado \xE9 obrigat\xF3rio"),
+  city: yup.string().required("A cidade \xE9 obrigat\xF3ria"),
+  address: yup.string().required("O endere\xE7o \xE9 obrigat\xF3rio"),
+});
+
+export type FormSchemaType = yup.InferType<typeof formSchema>;
+
+`;
+
+// src/templates/forms/schems/updateuser-form-scheme.ts
+var formSchemeUpdateUserTemplate = () => `
+import * as yup from "yup";
+
+export const updateFormSchema = yup.object({
+  photo: yup.string().url("Digite uma URL v\xE1lida para a foto").nullable().optional(),
+  bio: yup.string().max(500, "A bio deve ter no m\xE1ximo 500 caracteres").nullable().optional(),
+  skills: yup.string().max(100, "").nullable().optional(),
+  hourly_rate: yup.number().min(0, "O valor deve ser maior ou igual a 0").nullable().optional(),
+});
+
+export type UpdateFormSchemaType = yup.InferType<typeof updateFormSchema>;
+
+`;
+
+// src/templates/config/hiddenpaths.ts
+var hiddenPathsTemplate = () => `
+export const hiddenPaths = ["/manager", "/posts/new", "/posts", "/categories", "/categories/new", "/settings"];
+`;
+
+// src/templates/config/proxy.ts
+var proxyTemplate = () => `
+import { NextRequest, NextResponse } from "next/server";
+import { decoderTokenToClaims } from "./app/api/auth/decode-claims";
+
+type Role = "ADMIN" | "AUTHOR" | "COMMENTATOR";
+
+const adminRoutes = ["/admin", "/users", "/dashboard/admin", "/settings", "/desk/view"];
+const authorRoutes = ["/desk/view"];
+const commntatorRoutes = ["/community", "/messages", "/", "/announced"];
+
+export const config = {
+    matcher: [
+        "/admin/:path*", "/users/:path*", "/settings", "/settings/:path*", "/desk/view", "/desk/view/:path*", "/messages", "/messages/:path*"
+    ]
+};
+
+function canAccessRoute(path: string, role: Role) {
+    switch (role) {
+        case "ADMIN":
+            return (adminRoutes.some(r => path.startsWith(r)) || authorRoutes.some(r => path.startsWith(r)) || commntatorRoutes.some(r => path.startsWith(r)));
+
+        case "AUTHOR":
+            return authorRoutes.some(r => path.startsWith(r));
+
+        case "COMMENTATOR":
+            return commntatorRoutes.some(r => path.startsWith(r));
+
+        default:
+            return false;
+    };
+};
+
+export function proxy(request: NextRequest) {
+    const path = request.nextUrl.pathname;
+
+    const token = request.cookies.get("jwt_back")?.value;
+    if (!token) {
+        return NextResponse.redirect(new URL("/manager?error=not_has_token", request.url));
+    }
+
+    const claims = decoderTokenToClaims(token);
+    if (!claims) {
+        return NextResponse.redirect(new URL("/manager?error=invalid_token", request.url));
+    }
+
+    const role = claims.roles as Role;
+    const hasAccess = canAccessRoute(path, role);
+
+    if (!hasAccess) {
+        return NextResponse.redirect(new URL("/manager?error=invalid_role", request.url));
+    }
+
+    return NextResponse.next();
+}
+`;
+
+// src/templates/layouts/capture-error-layout.ts
+var captureErrorLayoutTemplate = () => `
+"use client";
+
+import { useSearchParams } from "next/navigation";
+import { type ReactNode } from "react";
+import { toast } from "react-toastify";
+import { useEffect } from "react";
+
+type LayoutCaptureErrorProps = { children: ReactNode; };
+
+export const LayoutCaptureError: React.FC<LayoutCaptureErrorProps> = ({ children }) => {
+  const searchParams = useSearchParams();
+  const error = searchParams.get("error");
+
+  useEffect(() => {
+    if (error) {
+      switch (error) {
+        case "not_has_token":
+          toast.error("Voc\xEA n\xE3o deveria nem estar aqui bixo, est\xE1 sem token de acesso.");
+          break;
+        case "invalid_token":
+          toast.error("Token inv\xE1lido, \xE9 de 1500 A.C");
+          break;
+        case "invalid_role":
+          toast.error("Voc\xEA n\xE3o \xE9 um usuario do tipo que pode mecher nisso a\xED major...");
+          break;
+        default:
+          toast.error("Ocorreu um erro desconhecido.");
+      }
+    }
+  }, [error]);
+  return (
+    <div style={{ width: "100%", height: "100%" }}>
+      {children}
+    </div>
+  );
+};
+`;
+
+// src/templates/layouts/main-layout.ts
+var mainLayoutTemplate = () => `
+import type { ReactNode } from "react";
+
+type TypeProps = { children: ReactNode[] };
+
+export const MainLayout = ({ children }: TypeProps) => {
+  const childrenArray = Array.isArray(children) ? children : [children];
+
+  if (childrenArray.length > 4)
+    throw new Error(
+      "MainLayout s\xF3 aceita no m\xE1ximo 4 elementos filhos: header, toast, main e footer."
+    );
+
+  return (
+    <div className="grid min-h-screen grid-rows-[auto_auto_1fr_auto]">
+      <header className="max-h-50">{childrenArray[0]}</header>
+      <div className="min-h-2.5 overflow-hidden bg-(--bg-section-100)">{childrenArray[1]}</div>
+      <main className="min-h-[60vh]">{childrenArray[2]}</main>
+      <footer className="h-87.5">{childrenArray[3]}</footer>
+    </div>
+  );
+};
+`;
+
+// src/templates/layouts/manager-layout.ts
+var managerLayoutTemplate = () => `
+"use client";
+
+import clsx from "clsx";
+import styles from "./grid.module.css";
+import { useMenu } from "@/contexts/manager-context";
+import { ReactNode } from "react";
+
+type ManagerLayoutProps = {
+  /** [0] header   [1] toast,
+   *  [2] sidebar, [3] conte\xFAdo,
+   *  [4] footer
+  **/
+  children: [ReactNode, ReactNode, ReactNode, ReactNode, ReactNode];
+};
+
+export const ManagerLayout: React.FC<ManagerLayoutProps> = ({ children }) => {
+  const [header, toastify, sidebar, content, footer] = children;
+  const { menuActive } = useMenu();
+
+  return (
+    <div className={clsx(styles.layout)} style={{ ["--aside-width" as any]: menuActive ? "80px" : "220px" }}>
+      <header className={clsx(styles.header)}>{header}</header>
+      <div className={clsx(styles.toastify)}>{toastify}</div>
+
+      <aside className={clsx(styles.side)}>{sidebar}</aside>
+      <main className={clsx(styles.content)}>{content}</main>
+
+      <footer className={clsx(styles.footer)}>{footer}</footer>
+    </div>
+  );
+};
+
+`;
+
+// src/templates/layouts/manager-layout-css.ts
+var managerLayoutCssTemplate = () => `
+.layout {
+  width: 100%;
+  display: grid;
+  grid-template-columns: var(--aside-width, 220px) 1fr;
+  grid-template-rows: auto auto auto auto;
+  grid-template-areas:
+    "header header"
+    "toast toast"
+    "side content"
+    "footer footer";
+  transition: grid-template-columns 0.3s ease;
+}
+
+.header {
+  grid-area: header;
+}
+
+.toastify {
+  grid-area: toast;
+  min-height: 2px;
+}
+
+.content {
+  grid-area: content;
+  min-height: 0;
+  overflow-y: auto;
+}
+
+.side {
+  grid-area: side;
+  min-width: 80px;
+  overflow: hidden;
+}
+
+.footer {
+  grid-area: footer;
+}
+
+@media (max-width: 768px) {
+  .layout {
+    grid-template-columns: 60px 1fr;
+  }
+}`;
+
+// src/templates/layouts/private-next-layout.ts
+var privateNextLayoutTemplate = () => `
+import { Footer } from "@/components/Footer";
+import { Header } from "@/components/Header";
+import { LayoutCaptureError } from "@/components/Layouts/LayoutCaptureError";
+import { ManagerLayout } from "@/components/Layouts/ManagerLayout";
+import { MenuAside } from "@/components/MenuAside";
+import { MenuProvider } from "@/contexts/manager-context";
+import { ToastContainer } from "react-toastify";
+import { Suspense } from "react";
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode; }>) {
+  return (
+      <div data-testid="root-layout-private">
+        <MenuProvider>
+          <ManagerLayout>
+            <Header />
+            <ToastContainer position="top-center" />
+            <MenuAside />
+            <Suspense fallback={null}>
+            <LayoutCaptureError>
+              {children}
+            </LayoutCaptureError>
+            </Suspense>
+            <Footer />
+          </ManagerLayout>
+        </MenuProvider>
+      </div>
+  );
+}
+`;
+
+// src/templates/layouts/root-next-layout.ts
+var rootLayoutMinimalTemplate = () => `
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "Create Next App",
+  description: "Generated by create next app",
+};
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode; }>) {
+  return (
+    <html lang="en">
+      <body className={\`\${geistSans.variable} \${geistMono.variable} antialiased\`} data-testid="root-layout">
+        {children}
+      </body>
+    </html>
+  );
+}
+`;
+
+// src/templates/layouts/public-next-layout.ts
+var publicLayoutTemplate = () => `
+import { Footer } from "@/components/Footer";
+import { Header } from "@/components/Header";
+import { MainLayout } from "@/components/Layouts/MainLayout";
+import { ToastContainer } from "react-toastify";
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode; }>) {
+  return (
+      <div data-testid="root-layout-public">
+       <MainLayout>
+          <Header />
+          <ToastContainer position="top-center" />
+          {children}
+          <Footer />
+        </MainLayout>
+      </div>
+  );
+}
+
+`;
+
+// src/utils/services/install-nextauth-motion.service.ts
+import { execSync as execSync4 } from "child_process";
+var DependencyFramemotionAndNextAuthInstaller = class _DependencyFramemotionAndNextAuthInstaller {
+  constructor() {
+    this.hasInstalled = false;
+  }
+  static getInstance() {
+    if (!_DependencyFramemotionAndNextAuthInstaller.instance) {
+      _DependencyFramemotionAndNextAuthInstaller.instance = new _DependencyFramemotionAndNextAuthInstaller();
+    }
+    return _DependencyFramemotionAndNextAuthInstaller.instance;
+  }
+  async install() {
+    if (this.hasInstalled || hasDependency("framer-motion")) return;
+    this.hasInstalled = true;
+    try {
+      execSync4(`npm install framer-motion && 
+                npm install next-auth &&
+                npm install jwt-decode &&
+                npm install --save-dev @types/jwt-decode
+                `, { stdio: "inherit" });
+      console.log("Depend\xEAncias instaladas com sucesso!");
+    } catch (error) {
+      console.error("Falha ao instalar depend\xEAncias:", error);
+    }
+    ;
+  }
+};
+
+// src/builders/next-auth-builder.ts
+var NextAuthBuilder = class {
+  constructor(options) {
+    this.options = options;
+  }
+  createCommit(message) {
+    if (!this.options?.git) return;
+    gitCommit(message);
+  }
+  installDependencesRequired() {
+    DependencyFramemotionAndNextAuthInstaller.getInstance().install();
+    return this;
+  }
+  setBasePathAndCreateConfig() {
+    this.basePath = path6.join(process.cwd(), "src/app/api/auth/[...nextauth]");
+    createDir(this.basePath);
+    if (!pathExists(this.basePath)) {
+      console.error("\x1B[31m \u2716 Erro \x1B[0m creating NextAuth config directory.");
+      process.exit(1);
+    }
+    ;
+    createFile(path6.join(this.basePath, "route.ts"), nextConfigTemplate());
+    if (this.options?.git) this.createCommit("feat(next-auth): create config route.");
+    return this;
+  }
+  createNextAuthAuxOptions() {
+    this.basePath = path6.join(process.cwd(), "src/app/api/auth/");
+    createFile(path6.join(this.basePath, "decode-claims.ts"), nextDecodeClaimsTemplate());
+    createFile(path6.join(this.basePath, "request-api.ts"), nextRequestApiTemplate());
+    this.basePath = path6.join(process.cwd(), "src/utils");
+    createDir(this.basePath);
+    if (!pathExists(this.basePath)) {
+      throw new Error(`Failed to create directory at ${this.basePath}`);
+    }
+    ;
+    createFile(path6.join(this.basePath, "route.ts"), nextSessionTypeTemplate());
+    if (!pathExists(this.basePath)) {
+      throw new Error(`Failed to create directory at ${this.basePath}`);
+    }
+    ;
+    createFile(path6.join(this.basePath, "utils.ts"), utilsTypeTemplate());
+    if (this.options?.git) this.createCommit("feat(next-auth): create aux options for login sessions.");
+    return this;
+  }
+  createNextAuthForms() {
+    const forms = [
+      { name: "FormForgot", template: formForgotTemplate, scheme: () => "" },
+      { name: "FormLogin", template: formLoginTemplate, scheme: formSchemeLoginTemplate },
+      { name: "FormRedef", template: formRedefTemplate, scheme: formSchemeRedefTemplate },
+      { name: "FormRegister", template: formRegisterTemplate, scheme: formSchemeRegisterTemplate },
+      { name: "FormUpdateUser", template: formUpdateUserTemplate, scheme: formSchemeUpdateUserTemplate }
+    ];
+    const formsRoot = path6.join(process.cwd(), "src/forms");
+    const usersPath = path6.join(formsRoot, "users");
+    let created = false;
+    if (!pathExists(formsRoot)) {
+      createDir(formsRoot);
+      created = true;
+    }
+    ;
+    if (!pathExists(usersPath)) {
+      createDir(usersPath);
+      created = true;
+    }
+    ;
+    forms.forEach(({ name, template, scheme }) => {
+      const formDir = path6.join(usersPath, name);
+      if (!pathExists(formDir)) {
+        createDir(formDir);
+        created = true;
+      }
+      ;
+      const filePath = path6.join(formDir, "index.tsx");
+      if (!pathExists(filePath)) {
+        createFile(filePath, template());
+        created = true;
+      }
+      ;
+      const schemePath = path6.join(formDir, `${name.toLocaleLowerCase() + "-scheme"}.tsx`);
+      if (!pathExists(schemePath)) {
+        createFile(schemePath, scheme());
+        created = true;
+      }
+      ;
+    });
+    this.basePath = path6.join(process.cwd(), "src/forms/users/FormLogin");
+    createFile(path6.join(this.basePath, "formwraper.tsx"), formLoginWrapperTemplate());
+    createFile(path6.join(this.basePath, "hidenpath.ts"), hiddenPathsTemplate());
+    const indexPath = path6.join(usersPath, "index.ts");
+    if (!pathExists(indexPath)) {
+      const exports = forms.map(({ name }) => `export { ${name} } from "./${name}";`).join("\n");
+      createFile(indexPath, exports + "\n");
+      created = true;
+    }
+    if (created && this.options?.git) {
+      this.createCommit("feat(auth): create next-auth user forms");
+    }
+    return this;
+  }
+  createNextLayouts() {
+    const layoutsRoot = path6.join(process.cwd(), "src/components/Layouts");
+    let created = false;
+    if (!pathExists(layoutsRoot)) {
+      createDir(layoutsRoot);
+      created = true;
+    }
+    const layouts = [
+      { name: "LayoutCaptureError", files: [{ name: "index.tsx", content: captureErrorLayoutTemplate() }] },
+      { name: "MainLayout", files: [{ name: "index.tsx", content: mainLayoutTemplate() }] },
+      { name: "ManagerLayout", files: [{ name: "index.tsx", content: managerLayoutTemplate() }, { name: "grid.module.css", content: managerLayoutCssTemplate() }] }
+    ];
+    layouts.forEach((layout) => {
+      const layoutDir = path6.join(layoutsRoot, layout.name);
+      if (!pathExists(layoutDir)) {
+        createDir(layoutDir);
+        created = true;
+      }
+      ;
+      layout.files.forEach((file) => {
+        const filePath = path6.join(layoutDir, file.name);
+        if (!pathExists(filePath)) {
+          createFile(filePath, file.content);
+          created = true;
+        }
+      });
+    });
+    if (created && this.options?.git) this.createCommit("feat(next-auth): compoenets for authentication system.");
+    return this;
+  }
+  setLayouts() {
+    const appRoot = path6.join(process.cwd(), "src/app");
+    const publicsDir = path6.join(appRoot, "(publics)");
+    const privatesDir = path6.join(appRoot, "(privates)");
+    const managerDir = path6.join(privatesDir, "manager");
+    let created = false;
+    if (!pathExists(publicsDir)) {
+      createDir(publicsDir);
+      created = true;
+    }
+    if (!pathExists(privatesDir)) {
+      createDir(privatesDir);
+      created = true;
+    }
+    if (!pathExists(managerDir)) {
+      createDir(managerDir);
+      created = true;
+    }
+    const rootLayout = path6.join(appRoot, "layout.tsx");
+    if (!pathExists(rootLayout)) {
+      createFile(rootLayout, rootLayoutMinimalTemplate());
+      created = true;
+    }
+    const rootPage = path6.join(appRoot, "page.tsx");
+    const publicsPage = path6.join(publicsDir, "page.tsx");
+    if (pathExists(rootPage) && !pathExists(publicsPage)) {
+      moveFile(rootPage, publicsPage);
+      created = true;
+    }
+    const publicsLayout = path6.join(publicsDir, "layout.tsx");
+    if (!pathExists(publicsLayout)) {
+      createFile(publicsLayout, publicLayoutTemplate());
+      created = true;
+    }
+    const privateLayoutPath = path6.join(privatesDir, "layout.tsx");
+    if (!pathExists(privateLayoutPath)) {
+      createFile(privateLayoutPath, privateNextLayoutTemplate());
+      created = true;
+    }
+    const managerPagePath = path6.join(managerDir, "page.tsx");
+    if (!pathExists(managerPagePath)) {
+      createFile(managerPagePath, managerPageTemplate());
+      created = true;
+    }
+    if (created && this.options?.git) {
+      this.createCommit("feat(app-router): created private and publics route groups");
+    }
+    ;
+    return this;
+  }
+  createComponentsAux() {
+    const root = process.cwd();
+    const contextsDir = path6.join(root, "src/contexts");
+    const componentsDir = path6.join(root, "src/components");
+    const headerDir = path6.join(componentsDir, "Header");
+    const footerDir = path6.join(componentsDir, "Footer");
+    const menuAsideDir = path6.join(componentsDir, "MenuAside");
+    const buttonGenericDir = path6.join(componentsDir, "ButtonGeneric");
+    let created = false;
+    if (!pathExists(contextsDir)) {
+      createDir(contextsDir);
+      created = true;
+    }
+    ;
+    const managerContextPath = path6.join(contextsDir, "manager-context.tsx");
+    if (!pathExists(managerContextPath)) {
+      createFile(managerContextPath, managerContextTemplate());
+      created = true;
+    }
+    if (!pathExists(componentsDir)) {
+      createDir(componentsDir);
+      created = true;
+    }
+    const components = [
+      { dir: headerDir, template: headerTemplate() },
+      { dir: footerDir, template: footerTemplate() },
+      { dir: menuAsideDir, template: menuAsideTemplate() },
+      { dir: buttonGenericDir, template: buttonGenericTemplate() }
+    ];
+    components.forEach((component) => {
+      if (!pathExists(component.dir)) {
+        createDir(component.dir);
+        created = true;
+      }
+      const indexPath = path6.join(component.dir, "index.tsx");
+      if (!pathExists(indexPath)) {
+        createFile(indexPath, component.template);
+        created = true;
+      }
+    });
+    if (created && this.options?.git) {
+      this.createCommit("feat(core): create manager context and essential layout components");
+    }
+    ;
+    return this;
+  }
+  createNextAutorizationSystem() {
+    this.basePath = path6.join(process.cwd(), "src");
+    createFile(path6.join(this.basePath, "proxy.ts"), proxyTemplate());
+    if (this.options?.git) this.createCommit("feat(next-auth): create proxy for autorize users in frontend.");
+    return this;
+  }
+  setEnvironmentVariable() {
+    this.basePath = path6.join(process.cwd());
+    createFile(path6.join(this.basePath, ".env.local"), environmentTemplate());
+    return this;
+  }
+  build() {
+    if (!this.options?.git) return;
+    console.log("commits made successfully \u2728");
+  }
+};
+
+// src/commands/create-nextauth-resource.ts
+function createNextAutResource(options) {
+  nextProjectGuardSimple();
+  const builder = new NextAuthBuilder(options);
+  builder.installDependencesRequired().setBasePathAndCreateConfig().createNextAuthAuxOptions().createNextAuthForms().createNextLayouts().setLayouts().createComponentsAux().createNextAutorizationSystem().setEnvironmentVariable().build();
+  console.log(`next auth configured \x1B[32m\u2714 success\x1B[0m`);
+}
+
+// src/builders/tests-builder.ts
+import path7 from "path";
+import fs4 from "fs";
+
+// src/templates/tests/config-vitest.ts
+var nextConfigViTestTemplate = () => `
+/// <reference types="vitest" />
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    globals: true,
+    setupFiles: "./vitest.setup.ts",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html"],
+    },
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});
+`;
+
+// src/utils/services/install-tests-unit-dependences.service.ts
+import { execSync as execSync5 } from "child_process";
+var DependencyTetsUnitInstaller = class _DependencyTetsUnitInstaller {
+  constructor() {
+    this.hasInstalled = false;
+  }
+  static getInstance() {
+    if (!_DependencyTetsUnitInstaller.instance) {
+      _DependencyTetsUnitInstaller.instance = new _DependencyTetsUnitInstaller();
+    }
+    return _DependencyTetsUnitInstaller.instance;
+  }
+  async install() {
+    if (this.hasInstalled || hasDependency("vitest")) return;
+    this.hasInstalled = true;
+    try {
+      execSync5(`
+                npm install -D vitest @testing-library/react @testing-library/jest-dom jsdom @types/node @vitest/ui @vitest/coverage-v8 
+            `, { stdio: "inherit" });
+      console.log("Depend\xEAncias instaladas com sucesso!");
+    } catch (error) {
+      console.error("Falha ao instalar depend\xEAncias:", error);
+    }
+    ;
+  }
+};
+
+// src/utils/services/install-tests-e2e-dependences.service.ts
+import { execSync as execSync6 } from "child_process";
+var DependencyTetsE2EInstaller = class _DependencyTetsE2EInstaller {
+  constructor() {
+    this.hasInstalled = false;
+  }
+  static getInstance() {
+    if (!_DependencyTetsE2EInstaller.instance) {
+      _DependencyTetsE2EInstaller.instance = new _DependencyTetsE2EInstaller();
+    }
+    return _DependencyTetsE2EInstaller.instance;
+  }
+  async install() {
+    if (this.hasInstalled || hasDependency("playwright")) return;
+    this.hasInstalled = true;
+    try {
+      execSync6(`npm install -D @playwright/test`, { stdio: "inherit" });
+      console.log("Depend\xEAncias instaladas com sucesso!");
+    } catch (error) {
+      console.error("Falha ao instalar depend\xEAncias:", error);
+    }
+    ;
+  }
+};
+
+// src/templates/tests/config-playwright.ts
+var nextConfigPlaywightTestTemplate = () => `
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  timeout: 30 * 1000, // 30s por teste
+  use: {
+    headless: true,          // false para abrir browser
+    viewport: { width: 1280, height: 720 },
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry', // \xFAtil para debugar
+  },
+  projects: [
+    {
+      name: 'Chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'Firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+    {
+      name: 'WebKit',
+      use: { ...devices['Desktop Safari'] },
+    },
+  ],
+  webServer: {
+    command: 'npm run dev',
+    port: 3000,
+    reuseExistingServer: !process.env.CI,
+  },
+});
+`;
+
+// src/builders/tests-builder.ts
+var TestsBuilder = class {
+  constructor(options) {
+    this.options = options;
+  }
+  createCommit(message) {
+    if (!this.options?.git) return;
+    gitCommit(message);
+  }
+  installDependencesViTestRequired() {
+    DependencyTetsUnitInstaller.getInstance().install();
+    return this;
+  }
+  installDependencesPlaywrightTestRequired() {
+    DependencyTetsE2EInstaller.getInstance().install();
+    return this;
+  }
+  setBasePathAndCreateConfigViTest() {
+    this.basePath = path7.join(process.cwd());
+    const vitestConfigPath = path7.join(this.basePath, "vitest.config.ts");
+    createFile(vitestConfigPath, nextConfigViTestTemplate());
+    const setupPath = path7.join(this.basePath, "vitest.setup.ts");
+    createFile(setupPath, 'import "@testing-library/jest-dom";\n');
+    const tsconfigPath = path7.join(this.basePath, "tsconfig.json");
+    if (pathExists(tsconfigPath)) {
+      const tsconfigRaw = fs4.readFileSync(tsconfigPath, "utf-8");
+      const tsconfig = JSON.parse(tsconfigRaw);
+      tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+      tsconfig.compilerOptions.types = tsconfig.compilerOptions.types || [];
+      if (!tsconfig.compilerOptions.types.includes("vitest/globals")) {
+        tsconfig.compilerOptions.types.push("vitest/globals");
+      }
+      fs4.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+    }
+    const packageJsonPath = path7.join(this.basePath, "package.json");
+    if (pathExists(packageJsonPath)) {
+      const packageJsonRaw = fs4.readFileSync(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonRaw);
+      packageJson.scripts = packageJson.scripts || {};
+      packageJson.scripts["test"] = "vitest";
+      packageJson.scripts["test:ui"] = "vitest --ui";
+      packageJson.scripts["test:run"] = "vitest run";
+      packageJson.scripts["test:coverage"] = "vitest run --coverage";
+      fs4.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    if (this.options?.git) this.createCommit("chore(tests-unit): setup Vitest and testing-library");
+    return this;
+  }
+  setBasePathAndCreatePlaywrightConfigTest() {
+    this.basePath = path7.join(process.cwd());
+    const playwrightConfigPath = path7.join(this.basePath, "playwright.config.ts");
+    createFile(playwrightConfigPath, nextConfigPlaywightTestTemplate());
+    const e2ePath = path7.join(this.basePath, "tests", "e2e");
+    createDir(e2ePath);
+    const packageJsonPath = path7.join(this.basePath, "package.json");
+    if (pathExists(packageJsonPath)) {
+      const packageJsonRaw = fs4.readFileSync(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonRaw);
+      packageJson.scripts = packageJson.scripts || {};
+      packageJson.scripts["e2e"] = "playwright test";
+      packageJson.scripts["e2e:headed"] = "playwright test --headed";
+      packageJson.scripts["e2e:report"] = "playwright show-report";
+      fs4.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    if (this.options?.git) this.createCommit("chore(tests): setup Playwright E2E");
+    return this;
+  }
+  build() {
+    if (!this.options?.git) return;
+    console.log("commits made successfully \u2728");
+  }
+};
+
+// src/commands/create-config-tests.ts
+function createTestUnitConfig(options) {
+  nextProjectGuardSimple();
+  const builder = new TestsBuilder(options);
+  builder.setBasePathAndCreateConfigViTest().installDependencesViTestRequired().build();
+  console.log(`resource configured \x1B[32m\u2714 Success\x1B[0m`);
+}
+function createTestE2EConfig(options) {
+  nextProjectGuardSimple();
+  const builder = new TestsBuilder(options);
+  builder.setBasePathAndCreatePlaywrightConfigTest().installDependencesPlaywrightTestRequired().build();
+  console.log(`resource configured \x1B[32m\u2714 Success\x1B[0m`);
+}
+
+// src/builders/resource-api-builder.ts
+import path8 from "path";
+var NextResourceApiBuilder = class extends NextAccelerateBuilder {
+  constructor(inputName, options) {
+    super(inputName, options);
+  }
+  setDefaultPath() {
+    this.basePath = path8.join(process.cwd(), "src/app/api");
+    if (pathExists(this.basePath)) return this;
+    createDir(this.basePath);
+    return this;
+  }
+  setBasePath() {
+    this.basePath = path8.join(process.cwd(), "src/app/api", this.resource);
+    if (pathExists(this.basePath)) return this;
+    createDir(this.basePath);
+    return this;
+  }
+  createCommonsApi() {
+    const apiBase = path8.join(process.cwd(), "src/app/api");
+    const imagesBase = path8.join(apiBase, "images");
+    const deleteBase = path8.join(apiBase, "delete");
+    if (pathExists(imagesBase) || pathExists(deleteBase)) {
+      console.log("\x1B[36m\u2139 Common API routes already initialized. Skipping...\x1B[0m");
+      return this;
+    }
+    const imageRoutePath = path8.join(imagesBase, "[resource]", "[resourceId]");
+    createDir(imageRoutePath);
+    createFile(path8.join(imageRoutePath, "route.ts"), imageUploadTemplate());
+    const deleteRoutePath = path8.join(deleteBase, "[resource]", "[resourceId]");
+    createDir(deleteRoutePath);
+    createFile(path8.join(deleteRoutePath, "route.ts"), deleteTemplate());
+    if (this.options?.git) this.createCommit("feat(api): add common resource routes");
+    return this;
+  }
+  createDefaultUsersApi() {
+    const apiBase = path8.join(process.cwd(), "src/app/api/users");
+    createDir(apiBase);
+    createFile(path8.join(apiBase, "route.ts"), usersCreateTemplate());
+    const photoPath = path8.join(apiBase, "photo");
+    createDir(photoPath);
+    createFile(path8.join(photoPath, "route.ts"), usersPhotoTemplate());
+    const updatePath = path8.join(apiBase, "update");
+    createDir(updatePath);
+    createFile(path8.join(updatePath, "route.ts"), usersUpdateTemplate());
+    if (this.options?.git) this.createCommit("feat(api): add resources for users api");
+    return this;
+  }
+  createResourceCrudApi() {
+    const resourceBase = path8.join(process.cwd(), "src/app/api", this.resource);
+    createDir(resourceBase);
+    createFile(path8.join(resourceBase, "route.ts"), createResourceTemplate(capitalize(this.resource)));
+    const paramFolder = `[${this.singular}Id]`;
+    const updatePath = path8.join(resourceBase, paramFolder);
+    createDir(updatePath);
+    createFile(path8.join(updatePath, "route.ts"), updateResourceTemplate(capitalize(this.singular), capitalize(this.resource)));
+    if (this.options?.git) this.createCommit(`feat(api/${this.resource}): add create and update routes`);
+    return this;
+  }
+};
+
+// src/commands/create-api-resource.ts
+function createCommonsApiResource(options) {
+  nextProjectGuardSimple();
+  const builder = new NextResourceApiBuilder("default", options);
+  builder.setDefaultPath().createCommonsApi().createDefaultUsersApi().build();
+  console.log(`the resources "$commons created \x1B[32m\u2714 Success\x1B[0m`);
+}
+function createApiResource(inputName, options) {
+  nextProjectGuardSimple();
+  if (!inputName) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mPlease provide the resource name.");
+    process.exit(1);
+  }
+  const builder = new NextResourceApiBuilder(inputName, options);
+  builder.setBasePath().createCommonsApi().createDefaultUsersApi().createResourceCrudApi().build();
+  console.log(`the resources "${inputName}" created \x1B[32m\u2714 Success\x1B[0m`);
+}
+
+// src/utils/interceptors/args.interceptor.ts
+var ALLOWED_FLAGS = /* @__PURE__ */ new Set(["--git", "--test", "--json"]);
+function useArgsInterceptor(args) {
+  const [, , ...input] = args;
+  if (input.length === 0) {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mNo command was entered.");
+    process.exit(1);
+  }
+  const command = input[0];
+  if (command.startsWith("-") && command !== "-help") {
+    console.error("\x1B[31m \u2716 Erro \x1B[0mInvalid command");
+    process.exit(1);
+  }
+  const rest = input.slice(1);
+  let resource;
+  const flags = [];
+  for (const token of rest) {
+    if (token.startsWith("-")) {
+      if (ALLOWED_FLAGS.has(token)) {
+        flags.push(token);
+        continue;
+      }
+      if (!resource) {
+        console.error("\x1B[31m \u2716 Erro \x1B[0mInvalid resource name");
+        process.exit(1);
+      }
+      console.error(`\x1B[31m \u2716 Erro \x1B[0mUnknown flag: ${token}`);
+      process.exit(1);
+    }
+    if (!resource) {
+      resource = token;
+      continue;
+    }
+    console.error("\x1B[31m \u2716 Erro \x1B[0mNo additional arguments are allowed.");
+    process.exit(1);
+  }
+  return { command, resource, flags };
+}
+
+// src/index.ts
+function main(args) {
+  const { command, resource, flags } = useArgsInterceptor(args);
+  const options = {
+    git: flags.includes("--git"),
+    test: flags.includes("--test"),
+    json: flags.includes("--json")
+  };
+  switch (command) {
+    case "create":
+      createResource(resource, options);
+      break;
+    case "create:components":
+      createComponents(options);
+      break;
+    case "create:form":
+      createFormForResource(resource, options);
+      break;
+    case "config:next-auth":
+      createNextAutResource(options);
+      break;
+    case "create:api-commons":
+      createCommonsApiResource(options);
+      break;
+    case "create:api-resource":
+      createApiResource(resource, options);
+      break;
+    case "config:tests-unit":
+      createTestUnitConfig(options);
+      break;
+    case "config:tests-e2e":
+      createTestE2EConfig(options);
+      break;
+    case "-help":
+      console.log("\n\n\x1B[35mcommands available in the cli: \x1B[0m");
+      console.log("  \x1B[32mcreate\x1B[0m \x1B[33mresource_name\x1B[0m                          -> creates all folders for a new resource.");
+      console.log("  \x1B[32mcreate:components\x1B[0m                             -> create components resource.");
+      console.log("  \x1B[32mcreate:form\x1B[0m \x1B[33mresource_name\x1B[0m                     -> creates a new form for the resource.");
+      console.log("  \x1B[32mconfig:next-auth\x1B[0m                              -> create configuration for next auth.");
+      console.log("  \x1B[32mcreate:api-commons\x1B[0m                            -> create common resources for using api routes.");
+      console.log("  \x1B[32mcreate:api-resource\x1B[0m \x1B[33mresource-name\x1B[0m             -> creates a new api resource.");
+      console.log("  \x1B[32mconfig:tests-unit\x1B[0m                             -> config tests unit with vitest.");
+      console.log("  \x1B[32mconfig:tests-e2e\x1B[0m                              -> config tests end to end with playwright.");
+      console.log("\n\n");
+      break;
+    default:
+      console.log("command unavailable in the cli...");
+  }
+  ;
+}
+main(process.argv);
+export {
+  main
+};