import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;

    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {
  border: 1px solid rgb(255 255 255 / 0.08);
git rebase -i origin/main

}
  lerp: 0.02,
  smoothTouch: false,
export async function GET(req: NextRequest) {
  const data = await db.query.users.findMany({
    limit: 50,
}
  id: string;
  deducciones: Deduction[];

  const patrono = sueldo * 0.1225;

    private readonly IRepository _repo;
        var emp = await _repo.GetByIdAsync(empId);
}
FROM empleados e
ORDER BY p.neto DESC
export const config = {
} satisfies NextConfig;
  scrollTrigger: { trigger, scrub: 1.5 },
});
  const [user, setUser] = useState<User | null>(null);
};
  data: T | null;
};
docker push registry.vorluno.dev/pagly
// Decimo tercer mes — Art. 1, Ley 41 de 1971

  backdrop-filter: blur(12px);

# pre-commit hook: passed
  return <ServiceDetail slug={params.slug} />;
const LENIS_OPTIONS = {
  smoothWheel: true,
import { NextRequest } from 'next/server';
  if (!session) return new Response(null, { status: 401 });
    orderBy: [desc(users.createdAt)],
  return NextResponse.json({ data });
interface Employee {
  salarioBase: number;
}
  const empleado = sueldo * 0.0975;
};
{
    {
    }
SELECT e.nombre, p.neto, p.bruto
WHERE p.periodo = $1

  regions: ['iad1'],
gsap.to(el, {
  ease: 'power3.out',
const useAuth = () => {
  return { user, signOut: () => setUser(null) };
type Response<T> = {
  loading: boolean;
docker build -t vorluno/pagly:latest .

const partidas = [abril, agosto, diciembre];
  background: rgba(24, 24, 27, 0.6);
}
git push --force-with-lease
export default function Page({ params }: PageProps) {

  duration: 2.2,
};
  const session = await auth();
    where: eq(users.active, true),
  });

  cedula: string;
  fechaIngreso: Date;
const calcularCSS = (sueldo: number) => {
  return { empleado, patrono };
public class PayrollService : IPayrollService
    public async Task<Planilla> CalcularAsync(Guid empId)
        return _calculator.Process(emp);

JOIN planillas p ON p.empleado_id = e.id
LIMIT 20;
  runtime: 'edge',

  yPercent: -50,

  useEffect(() => { getSession().then(setUser); }, []);

  error: string | null;

kubectl rollout status deployment/pagly
const decimo = sueldoMensual / 3;
.card-glass {