next-accelerate 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/builders/resource-builder.ts
-import path from "path";
+import path4 from "path";
 import pluralize from "pluralize";
 
 // src/templates/forms/create-form.ts
@@ -40,16 +40,16 @@ var formCreateTemplate = (resourceInSingular, resourceInPlural) => `
           const uploadResp = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/images/posts/\${post.postId}\`, { method: "POST", body: formData });
 
           if (uploadResp.ok) {
-            toast.success("recurso criado com sucesso!");
+            toast.success("Resource created successfully!");
             router.refresh();
             router.push("/manager");
           }
-          else { toast.error("Nenhuma foto foi selecionada."); }
+          else { toast.error("No photos were selected."); }
         } else {
           toast.error("Erro ao criar o recurso.");
         }
       } catch (err) {
-        toast.error("Erro ao comunicar com o servidor.");
+        toast.error("Error communicating with the server.");
       }
     };
 
@@ -149,7 +149,7 @@ export const FormDeleteResource: React.FC<FormDeleteResourceProps> = ({ resource
     try {
       const response = await fetch(\`\${process.env.NEXT_PUBLIC_FRONTEND_URL}/api/delete/\${resource}/\${resourceId}\`, { method: "POST" });
       if (response.ok) {
-        toast.success("Deletado com sucesso");
+        toast.success("Deleted successfully!");
         router.push("/manager");
       }
       else {
@@ -445,6 +445,54 @@ var newPageTemplate = (resourceInSingular, resourceInPlural) => `
   }
 `;
 
+// src/templates/pages/manager-page.ts
+var managerPageTemplate = () => `
+import { authOptions } from "@/app/api/auth/[...nextauth]/route";
+import { Session } from "@/utils/session";
+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";
@@ -522,8 +570,598 @@ var inputTemplate = () => `
   };
 `;
 
+// 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/singout.ts
+var nextSignOutTemplate = () => `
+import { NextApiRequest, NextApiResponse } from 'next';
+import { signOut } from 'next-auth/react';
+
+export default async (req: NextApiRequest, res: NextApiResponse) => {
+  if (req.method === 'POST') {
+    try {
+      await signOut({ redirect: false });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      res.status(500).json({ message: 'Erro ao realizar logout', error: errorMessage });
+    }
+  } else {
+    res.status(405).json({ message: 'Method not allowed' });
+  }
+};
+`;
+
+// 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/environment.ts
+var environmentTemplate = () => `
+NEXTAUTH_URL=http://localhost:3000
+NEXTAUTH_SECRET=secret_key
+`;
+
+// src/templates/forms/forgot-form.ts
+var formForgotTemplate = () => `
+"use client";
+
+import { sendEmailServerSideProps, Response } from "@/utils/actions";
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { FormEvent, useEffect, useState } from "react";
+import { toast } from "react-toastify";
+
+export const FormForgot = () => {
+    const [data, setData] = useState<Response>({ statusCode: 0, message: '' });
+
+    useEffect(() => { }, [data]);
+
+    const handleSubmit = async (e: FormEvent<HTMLFormElement>) => {
+        e.preventDefault();
+        const email = (e.target as HTMLFormElement).email.value;
+        const data = await sendEmailServerSideProps(email);
+        setData(data);
+        if (data.statusCode != 200) {
+            toast.error(data.message);
+        } else {
+            redirect('/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" type="email" 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 { redirect } from 'next/navigation';
+import { yupResolver } from '@hookform/resolvers/yup';
+import { formSchema } from './formredef-scheme';
+import { IFormInputRedem, sendRedemServerSideProps } from '../../../utils/actions';
+import { InputCustom } from '@/components/Shared/Inputs';
+
+export const FormRedef = () => {
+  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) {
+      redirect("/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">Registrar</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 { updateFormSchema, UpdateFormSchemaType } from "./formregister-scheme";
+import { useSession } from "next-auth/react";
+import { InputCustom } from "@/components/Shared/Inputs";
+import { ButtonGeneric } from "@/components/Shared/Buttons/ButtonGeneric";
+import { UpdateUserInput } from "@/utils/users";
+
+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/Shared/Inputs";
+import { ButtonGeneric } from "@/components/Shared/Buttons/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(\`http://localhost:3001/api/users\`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+      });
+
+      if (response && response.status === 201) {
+        toast.success("Usu\xE1rio criado com sucesso, 1 seg e ser\xE1 redirecionado!");
+        router.push("/");
+      } else {
+        toast.error(response.status === 400 ? "Email j\xE1 existe na aplica\xE7\xE3o, prossiga para redefini\xE7\xE3o de senha" : "Erro ao registrar");
+      }
+    } catch (error) {
+      throw new Error("Ocorreu um erro de comunica\xE7\xE3o no Next...");
+    }
+  };
+
+  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 });
@@ -538,6 +1176,15 @@ var createFile = (filePath, content) => {
 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);
@@ -643,6 +1290,42 @@ function gitCommit(message) {
 
 // src/utils/services/install-dependences.service.ts
 import { execSync as execSync2 } 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;
@@ -654,11 +1337,11 @@ var DependencyInstaller = class _DependencyInstaller {
     return _DependencyInstaller.instance;
   }
   async install() {
-    if (this.hasInstalled) return;
+    if (this.hasInstalled || hasDependency("react-hook-form")) return;
     this.hasInstalled = true;
     try {
       execSync2(`
-                npm i lucide-react &&
+                npm install lucide-react &&
                 npm install next-auth &&
                 npm install jwt-decode &&
                 npm install --save-dev @types/jwt-decode &&
@@ -680,7 +1363,6 @@ var DependencyInstaller = class _DependencyInstaller {
 var NextResourceBuilder = class {
   constructor(inputName, options) {
     this.inputName = inputName;
-    this.commitQueue = [];
     this.options = options;
     this.resource = pluralize(inputName.toLowerCase());
     this.singular = pluralize.singular(this.resource);
@@ -689,132 +1371,983 @@ var NextResourceBuilder = class {
     if (!this.options?.git) return;
     gitCommit(message);
   }
-  registerCommit(message) {
-    if (!this.options?.git) return;
-    this.commitQueue.push(message);
-  }
   setBasePath() {
-    this.basePath = path.join(process.cwd(), "src/app/(privates)", this.resource);
+    this.basePath = path4.join(process.cwd(), "src/app/(privates)", this.resource);
     createDir(this.basePath);
     return this;
   }
   setBasePathForForm() {
-    this.basePath = path.join(process.cwd(), "src/forms");
+    this.basePath = path4.join(process.cwd(), "src/forms");
     createDir(this.basePath);
     return this;
   }
   setBasePathForComponents() {
-    this.basePath = path.join(process.cwd(), "src/components");
+    this.basePath = path4.join(process.cwd(), "src/components");
     createDir(this.basePath);
     return this;
   }
   createComponentInputCustom() {
-    const componentPath = path.join(this.basePath, "Inputs/InputCustom");
+    const componentPath = path4.join(this.basePath, "Inputs/InputCustom");
     createDir(componentPath);
-    createFile(path.join(componentPath, "index.tsx"), inputTemplate());
-    if (this.options?.git) this.createCommit(`feat(${this.resource}): add input custom component`);
+    createFile(path4.join(componentPath, "index.tsx"), inputTemplate());
+    if (this.options?.git) this.createCommit(`feat(input): add input custom component`);
     return this;
   }
   createListPage() {
-    createFile(path.join(this.basePath, "page.tsx"), listPageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path4.join(this.basePath, "page.tsx"), listPageTemplate(capitalize(this.singular), capitalize(this.resource)));
     return this;
   }
   createDetailPage() {
-    const detailDir = path.join(this.basePath, `[${this.singular}Id]`);
+    const detailDir = path4.join(this.basePath, `[${this.singular}Id]`);
     createDir(detailDir);
-    createFile(path.join(detailDir, "page.tsx"), detailPageTemplate(capitalize(this.singular)));
-    const editDir = path.join(detailDir, "edit");
+    createFile(path4.join(detailDir, "page.tsx"), detailPageTemplate(capitalize(this.singular)));
+    const editDir = path4.join(detailDir, "edit");
     createDir(editDir);
-    createFile(path.join(editDir, "page.tsx"), updatePageTemplate(capitalize(this.singular), capitalize(this.resource)));
-    const deleteDir = path.join(detailDir, "delete");
+    createFile(path4.join(editDir, "page.tsx"), updatePageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    const deleteDir = path4.join(detailDir, "delete");
     createDir(deleteDir);
-    createFile(path.join(deleteDir, "page.tsx"), deletePageTemplate(capitalize(this.singular)));
-    this.registerCommit(`feat(${this.resource}): add all pages for detail view`);
+    createFile(path4.join(deleteDir, "page.tsx"), deletePageTemplate(capitalize(this.singular)));
+    this.createCommit(`feat(${this.resource}): add all pages for detail view`);
     return this;
   }
   createNewPage() {
-    const dir = path.join(this.basePath, "new");
+    const dir = path4.join(this.basePath, "new");
     createDir(dir);
-    createFile(path.join(dir, "page.tsx"), newPageTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path4.join(dir, "page.tsx"), newPageTemplate(capitalize(this.singular), capitalize(this.resource)));
     return this;
   }
   createCrudForm() {
-    const sharedPath = path.join(this.basePath, "shared");
-    const deletePath = path.join(sharedPath, "FormDelete");
+    const sharedPath = path4.join(this.basePath, "shared");
+    const deletePath = path4.join(sharedPath, "FormDelete");
     if (!pathExists(deletePath)) {
       createDir(sharedPath);
       createDir(deletePath);
-      createFile(path.join(deletePath, "index.tsx"), formDeleteTemplate(capitalize(this.singular), capitalize(this.resource)));
-      createFile(path.join(sharedPath, "index.ts"), `export { FormDeleteResource } from "./FormDelete";
+      createFile(path4.join(deletePath, "index.tsx"), formDeleteTemplate(capitalize(this.singular), capitalize(this.resource)));
+      createFile(path4.join(sharedPath, "index.ts"), `export { FormDeleteResource } from "./FormDelete";
 `);
     }
-    const resourcePath = path.join(this.basePath, this.resource);
+    const resourcePath = path4.join(this.basePath, this.resource);
     createDir(resourcePath);
     DependencyInstaller.getInstance().install();
-    const formNewPath = path.join(resourcePath, "FormNew");
+    const formNewPath = path4.join(resourcePath, "FormNew");
     createDir(formNewPath);
-    createFile(path.join(formNewPath, "index.tsx"), formCreateTemplate(capitalize(this.singular), capitalize(this.resource)));
-    createFile(path.join(formNewPath, "form-scheme.ts"), formSchemeCreateTemplate());
-    const formEditPath = path.join(resourcePath, "FormEdit");
+    createFile(path4.join(formNewPath, "index.tsx"), formCreateTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path4.join(formNewPath, "form-scheme.ts"), formSchemeCreateTemplate());
+    const formEditPath = path4.join(resourcePath, "FormEdit");
     createDir(formEditPath);
-    createFile(path.join(formEditPath, "index.tsx"), formUpdateTemplate(capitalize(this.singular), capitalize(this.resource)));
-    createFile(path.join(formEditPath, "form-scheme.ts"), formSchemeUpdateTemplate(capitalize(this.singular), capitalize(this.resource)));
-    createFile(path.join(resourcePath, "index.ts"), `
+    createFile(path4.join(formEditPath, "index.tsx"), formUpdateTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path4.join(formEditPath, "form-scheme.ts"), formSchemeUpdateTemplate(capitalize(this.singular), capitalize(this.resource)));
+    createFile(path4.join(resourcePath, "index.ts"), `
       export { FormNew${capitalize(this.singular)} } from "./FormNew";
 
       export { FormEdit${capitalize(this.singular)} } from "./FormEdit";
     `);
-    this.registerCommit(`feat(${this.resource}): created crud form components`);
+    this.createCommit(`feat(${this.resource}): created crud form components`);
     return this;
   }
   build() {
     if (!this.options?.git) return;
-    for (const message of this.commitQueue) {
-      gitCommit(message);
-    }
+    console.log("commits made successfully \u2728");
   }
 };
 
-// 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/commands/create-resource.ts
 function createResource(inputName, options) {
   nextProjectGuardSimple();
   if (!inputName) {
-    console.error("\x1B[31m \u2716 Erro \x1B[0mInforme o nome do recurso");
+    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(`Recurso "${inputName}" criado \x1B[32m\u2714 Sucesso\x1B[0m`);
+  console.log(`Resource "${inputName}" created \x1B[32m\u2714 Success\x1B[0m`);
 }
 
 // src/commands/create-form-resource.ts
 function createFormForResource(inputName, options) {
   nextProjectGuardSimple();
   if (!inputName) {
-    console.error("\x1B[31m \u2716 Erro \x1B[0mInforme o nome do recurso");
+    console.error("\x1B[31m \u2716 Erro \x1B[0mPlease provide the resource name.");
     process.exit(1);
   }
   const builder = new NextResourceBuilder(inputName, options);
   builder.setBasePathForComponents().createComponentInputCustom().setBasePathForForm().createCrudForm().build();
-  console.log(`Form para o recurso "${inputName}" criado \x1B[32m\u2714 Sucesso\x1B[0m`);
+  console.log(`Form for the resource "${inputName}" created \x1B[32m\u2714 Success\x1B[0m`);
+}
+
+// src/builders/next-auth-builder.ts
+import path5 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";
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode; }>) {
+  return (
+      <div data-testid="root-layout-private">
+        <MenuProvider>
+          <ManagerLayout>
+            <Header />
+            <ToastContainer position="top-center" />
+            <MenuAside />
+            <LayoutCaptureError>
+              {children}
+            </LayoutCaptureError>
+            <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/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>
+    );
+};
+`;
+
+// src/utils/services/install-frame-motion.service.ts
+import { execSync as execSync3 } from "child_process";
+var DependencyFramemotionInstaller = class _DependencyFramemotionInstaller {
+  constructor() {
+    this.hasInstalled = false;
+  }
+  static getInstance() {
+    if (!_DependencyFramemotionInstaller.instance) {
+      _DependencyFramemotionInstaller.instance = new _DependencyFramemotionInstaller();
+    }
+    return _DependencyFramemotionInstaller.instance;
+  }
+  async install() {
+    if (this.hasInstalled || hasDependency("framer-motion")) return;
+    this.hasInstalled = true;
+    try {
+      execSync3(`npm install framer-motion`, { 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.commitQueue = [];
+    this.options = options;
+  }
+  createCommit(message) {
+    if (!this.options?.git) return;
+    gitCommit(message);
+  }
+  registerCommit(message) {
+    if (!this.options?.git) return;
+    this.commitQueue.push(message);
+  }
+  setBasePathAndCreateConfig() {
+    this.basePath = path5.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(path5.join(this.basePath, "route.ts"), nextConfigTemplate());
+    if (this.options?.git) this.createCommit("feat(next-auth): create config route.");
+    return this;
+  }
+  createNextAuthAuxOptions() {
+    this.basePath = path5.join(process.cwd(), "src/app/api/auth/");
+    createFile(path5.join(this.basePath, "decode-claims.ts"), nextDecodeClaimsTemplate());
+    createFile(path5.join(this.basePath, "request-api.ts"), nextRequestApiTemplate());
+    createFile(path5.join(this.basePath, "singout.ts"), nextSignOutTemplate());
+    this.basePath = path5.join(process.cwd(), "src/utils");
+    createDir(this.basePath);
+    if (!pathExists(this.basePath)) {
+      throw new Error(`Failed to create directory at ${this.basePath}`);
+    }
+    ;
+    createFile(path5.join(this.basePath, "route.ts"), nextSessionTypeTemplate());
+    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 = path5.join(process.cwd(), "src/forms");
+    const usersPath = path5.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 = path5.join(usersPath, name);
+      if (!pathExists(formDir)) {
+        createDir(formDir);
+        created = true;
+      }
+      ;
+      const filePath = path5.join(formDir, "index.tsx");
+      if (!pathExists(filePath)) {
+        createFile(filePath, template());
+        created = true;
+      }
+      ;
+      const schemePath = path5.join(formDir, `${name.toLocaleLowerCase() + "-scheme"}.tsx`);
+      if (!pathExists(schemePath)) {
+        createFile(schemePath, scheme());
+        created = true;
+      }
+      ;
+    });
+    this.basePath = path5.join(process.cwd(), "src/forms/users/FormLogin");
+    createFile(path5.join(this.basePath, "formwraper.tsx"), formLoginWrapperTemplate());
+    createFile(path5.join(this.basePath, "hidenpath.ts"), hiddenPathsTemplate());
+    const indexPath = path5.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.registerCommit("feat(auth): create next-auth user forms");
+    }
+    return this;
+  }
+  createNextAutorizationSystem() {
+    this.basePath = path5.join(process.cwd(), "src");
+    createFile(path5.join(this.basePath, "proxy.ts"), proxyTemplate());
+    if (this.options?.git) this.createCommit("feat(next-auth): create proxy for autorize users in frontend.");
+    return this;
+  }
+  createNextLayouts() {
+    const layoutsRoot = path5.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 = path5.join(layoutsRoot, layout.name);
+      if (!pathExists(layoutDir)) {
+        createDir(layoutDir);
+        created = true;
+      }
+      ;
+      layout.files.forEach((file) => {
+        const filePath = path5.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 = path5.join(process.cwd(), "src/app");
+    const publicsDir = path5.join(appRoot, "(publics)");
+    const privatesDir = path5.join(appRoot, "(privates)");
+    const managerDir = path5.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 = path5.join(appRoot, "layout.tsx");
+    if (!pathExists(rootLayout)) {
+      createFile(rootLayout, rootLayoutMinimalTemplate());
+      created = true;
+    }
+    const rootPage = path5.join(appRoot, "page.tsx");
+    const publicsPage = path5.join(publicsDir, "page.tsx");
+    if (pathExists(rootPage) && !pathExists(publicsPage)) {
+      moveFile(rootPage, publicsPage);
+      created = true;
+    }
+    const publicsLayout = path5.join(publicsDir, "layout.tsx");
+    if (!pathExists(publicsLayout)) {
+      createFile(publicsLayout, publicLayoutTemplate());
+      created = true;
+    }
+    const privateLayoutPath = path5.join(privatesDir, "layout.tsx");
+    if (!pathExists(privateLayoutPath)) {
+      createFile(privateLayoutPath, privateNextLayoutTemplate());
+      created = true;
+    }
+    const managerPagePath = path5.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 = path5.join(root, "src/contexts");
+    const componentsDir = path5.join(root, "src/components");
+    const headerDir = path5.join(componentsDir, "Header");
+    const footerDir = path5.join(componentsDir, "Footer");
+    const menuAsideDir = path5.join(componentsDir, "MenuAside");
+    const buttonGenericDir = path5.join(componentsDir, "ButtonGeneric");
+    DependencyFramemotionInstaller.getInstance().install();
+    let created = false;
+    if (!pathExists(contextsDir)) {
+      createDir(contextsDir);
+      created = true;
+    }
+    ;
+    const managerContextPath = path5.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 = path5.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;
+  }
+  setEnvironmentVariable() {
+    this.basePath = path5.join(process.cwd());
+    createFile(path5.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.setBasePathAndCreateConfig().createNextAuthAuxOptions().createNextAuthForms().createNextLayouts().setLayouts().createComponentsAux().createNextAutorizationSystem().setEnvironmentVariable().build();
+  console.log(`next auth configured \x1B[32m\u2714 success\x1B[0m`);
 }
 
 // src/utils/interceptors/args.interceptor.ts
@@ -867,10 +2400,14 @@ function main(args) {
     case "create:form":
       createFormForResource(resource, { git: useGit });
       break;
+    case "config:next-auth":
+      createNextAutResource({ git: useGit });
+      break;
     case "-help":
       console.log("commands available in the cli:");
       console.log("  create <resource-name> - creates all folders for a new resource.");
       console.log("  create:form <resource-name> - creates a new form for the resource");
+      console.log("  config:next-auth - creates a new form for the resource");
       break;
     default:
       console.log("command unavailable in the cli...");