feat: Implementar sistema de disponibilidad y corregir errores de kiosko

- Agregar API routes de disponibilidad (blocks, staff, time-slots, staff-unavailable)
- Corregir autenticación en availability routes (reemplazar get_current_user_role con validación Bearer)
- Corregir DELETE en blocks/route.ts para usar query parameters
- Corregir errores de tipos en kiosk routes (supabase → supabaseAdmin)
- Agregar layout raíz de Next.js y estilos globales
- Agregar componente Badge UI
- Corregir tipos TypeScript en WalkInFlow
- Instalar dependencias necesarias (@radix-ui/*, class-variance-authority, etc)
- Agregar migraciones de disponibilidad

app/api/availability/blocks/route.ts

@@ -0,0 +1,200 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { supabaseAdmin } from '@/lib/supabase/client'
+
+async function validateAdmin(request: NextRequest) {
+  const authHeader = request.headers.get('authorization')
+  
+  if (!authHeader) {
+    return null
+  }
+
+  const token = authHeader.replace('Bearer ', '')
+  
+  if (token !== process.env.ADMIN_ENROLLMENT_KEY) {
+    return null
+  }
+
+  return true
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const isAdmin = await validateAdmin(request)
+    
+    if (!isAdmin) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const {
+      location_id,
+      resource_id,
+      start_time_utc,
+      end_time_utc,
+      reason
+    } = body
+
+    if (!location_id || !resource_id || !start_time_utc || !end_time_utc) {
+      return NextResponse.json(
+        { error: 'Missing required fields: location_id, resource_id, start_time_utc, end_time_utc' },
+        { status: 400 }
+      )
+    }
+
+    const { data: block, error: blockError } = await supabaseAdmin
+      .from('booking_blocks')
+      .insert({
+        location_id,
+        resource_id,
+        start_time_utc,
+        end_time_utc,
+        reason
+      })
+      .select()
+      .single()
+
+    if (blockError || !block) {
+      return NextResponse.json(
+        { error: blockError?.message || 'Failed to create booking block' },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      block
+    })
+  } catch (error) {
+    console.error('Booking blocks POST error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const isAdmin = await validateAdmin(request)
+    
+    if (!isAdmin) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const { searchParams } = new URL(request.url)
+    const locationId = searchParams.get('location_id')
+    const startDate = searchParams.get('start_date')
+    const endDate = searchParams.get('end_date')
+
+    let query = supabaseAdmin
+      .from('booking_blocks')
+      .select(`
+        id,
+        location_id,
+        resource_id,
+        start_time_utc,
+        end_time_utc,
+        reason,
+        created_at,
+        location (
+          id,
+          name
+        ),
+        resource (
+          id,
+          name,
+          type
+        ),
+        created_by (
+          id,
+          display_name
+        )
+      `)
+
+    if (locationId) {
+      query = query.eq('location_id', locationId)
+    }
+
+    if (startDate) {
+      query = query.gte('start_time_utc', startDate)
+    }
+
+    if (endDate) {
+      query = query.lte('end_time_utc', endDate)
+    }
+
+    const { data: blocks, error } = await query.order('start_time_utc', { ascending: true })
+
+    if (error) {
+      return NextResponse.json(
+        { error: error.message },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({ 
+      blocks: blocks || [],
+      total: blocks?.length || 0
+    })
+  } catch (error) {
+    console.error('Booking blocks GET error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      {        status: 500 }
+    )
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  try {
+    const isAdmin = await validateAdmin(request)
+    
+    if (!isAdmin) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const { searchParams } = new URL(request.url)
+    const blockId = searchParams.get('id')
+
+    if (!blockId) {
+      return NextResponse.json(
+        { error: 'Missing required parameter: id' },
+        { status: 400 }
+      )
+    }
+
+    const { data: block, error: blockError } = await supabaseAdmin
+      .from('booking_blocks')
+      .delete()
+      .eq('id', blockId)
+      .select()
+      .single()
+
+    if (blockError) {
+      return NextResponse.json(
+        { error: blockError?.message || 'Block not found' },
+        { status: 404 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: 'Booking block deleted successfully'
+    })
+  } catch (error) {
+    console.error('Booking blocks DELETE error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/availability/staff-unavailable/route.ts

@@ -0,0 +1,178 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { supabaseAdmin } from '@/lib/supabase/client'
+
+async function validateAdminOrStaff(request: NextRequest) {
+  const authHeader = request.headers.get('authorization')
+  
+  if (!authHeader) {
+    return null
+  }
+
+  const token = authHeader.replace('Bearer ', '')
+  
+  if (token !== process.env.ADMIN_ENROLLMENT_KEY) {
+    return null
+  }
+
+  return true
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const hasAccess = await validateAdminOrStaff(request)
+    
+    if (!hasAccess) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const {
+      staff_id,
+      date,
+      start_time,
+      end_time,
+      reason,
+      location_id
+    } = body
+
+    if (!staff_id || !date || !start_time || !end_time) {
+      return NextResponse.json(
+        { error: 'Missing required fields: staff_id, date, start_time, end_time' },
+        { status: 400 }
+      )
+    }
+
+    const { data: staff, error: staffError } = await supabaseAdmin
+      .from('staff')
+      .select('id, location_id')
+      .eq('id', staff_id)
+      .single()
+
+    if (staffError || !staff) {
+      return NextResponse.json(
+        { error: staffError?.message || 'Staff not found' },
+        { status: 400 }
+      )
+    }
+
+    const { data: availability, error: availabilityError } = await supabaseAdmin.rpc('check_staff_availability', {
+      p_staff_id: staff_id,
+      p_start_time_utc: `${date}T${start_time}Z`,
+      p_end_time_utc: `${date}T${end_time}Z`
+    })
+
+    if (availabilityError) {
+      return NextResponse.json(
+        { error: availabilityError.message },
+        { status: 400 }
+      )
+    }
+
+    const { data: existingAvailability } = await supabaseAdmin
+      .from('staff_availability')
+      .select('*')
+      .eq('staff_id', staff_id)
+      .eq('date', date)
+      .single()
+
+    if (existingAvailability) {
+      return NextResponse.json(
+        { error: 'Availability already exists for this staff and date' },
+        { status: 400 }
+      )
+    }
+
+    const { data: newAvailability, error: createError } = await supabaseAdmin
+      .from('staff_availability')
+      .insert({
+        staff_id,
+        date,
+        start_time,
+        end_time,
+        is_available: false,
+        reason,
+        created_by: staff_id
+      })
+      .select()
+      .single()
+
+    if (createError) {
+      return NextResponse.json(
+        { error: createError.message },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      availability: newAvailability
+    })
+  } catch (error) {
+    console.error('Staff unavailable POST error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const hasAccess = await validateAdminOrStaff(request)
+    
+    if (!hasAccess) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const { searchParams } = new URL(request.url)
+    const staffId = searchParams.get('staff_id')
+    const startDate = searchParams.get('start_date')
+    const endDate = searchParams.get('end_date')
+
+    if (!staffId) {
+      return NextResponse.json(
+        { error: 'Missing required parameter: staff_id' },
+        { status: 400 }
+      )
+    }
+
+    let query = supabaseAdmin
+      .from('staff_availability')
+      .select('*')
+      .eq('staff_id', staffId)
+
+    if (startDate) {
+      query = query.gte('date', startDate)
+    }
+
+    if (endDate) {
+      query = query.lte('date', endDate)
+    }
+
+    const { data: availabilityList, error } = await query.order('date', { ascending: true })
+
+    if (error) {
+      return NextResponse.json(
+        { error: error.message },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      availability: availabilityList || []
+    })
+  } catch (error) {
+    console.error('Staff unavailable GET error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/availability/staff/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { supabaseAdmin } from '@/lib/supabase/client'
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url)
+    const locationId = searchParams.get('location_id')
+    const startTime = searchParams.get('start_time_utc')
+    const endTime = searchParams.get('end_time_utc')
+
+    if (!locationId || !startTime || !endTime) {
+      return NextResponse.json(
+        { error: 'Missing required parameters: location_id, start_time_utc, end_time_utc' },
+        { status: 400 }
+      )
+    }
+
+    const { data: staff, error: staffError } = await supabaseAdmin.rpc('get_available_staff', {
+      p_location_id: locationId,
+      p_start_time_utc: startTime,
+      p_end_time_utc: endTime
+    })
+
+    if (staffError) {
+      return NextResponse.json(
+        { error: staffError.message },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      staff: staff || [],
+      location_id: locationId,
+      start_time_utc: startTime,
+      end_time_utc: endTime,
+      available_count: staff?.length || 0
+    })
+  } catch (error) {
+    console.error('Available staff GET error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/availability/time-slots/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { supabaseAdmin } from '@/lib/supabase/client'
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url)
+    const locationId = searchParams.get('location_id')
+    const serviceId = searchParams.get('service_id')
+    const date = searchParams.get('date')
+
+    if (!locationId || !date) {
+      return NextResponse.json(
+        { error: 'Missing required parameters: location_id, date' },
+        { status: 400 }
+      )
+    }
+
+    const timeSlotDuration = parseInt(searchParams.get('time_slot_duration_minutes') || '60', 10);
+
+    const { data: availability, error } = await supabaseAdmin.rpc('get_detailed_availability', {
+      p_location_id: locationId,
+      p_service_id: serviceId,
+      p_date: date,
+      p_time_slot_duration_minutes: timeSlotDuration
+    })
+
+    if (error) {
+      console.error('RPC error:', error);
+      return NextResponse.json(
+        { error: error.message },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      availability
+    })
+  } catch (error) {
+    console.error('Time slots GET error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/kiosk/authenticate/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { supabase } from '@/lib/supabase/client'
+import { supabaseAdmin } from '@/lib/supabase/client'
 import { Kiosk } from '@/lib/db/types'
 
 export async function POST(request: NextRequest) {
   try {
-    const { api_key } = await request.json()
+    const body = await request.json()
+    console.log('Auth request body:', body)
+    const { api_key } = body
 
     if (!api_key || typeof api_key !== 'string') {
       return NextResponse.json(
@@ -13,7 +15,8 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const { data: kiosk, error } = await supabase
+    console.log('Querying kiosk with api_key:', api_key)
+    const { data: kiosk, error } = await supabaseAdmin
       .from('kiosks')
       .select(`
         id,
@@ -21,7 +24,7 @@ export async function POST(request: NextRequest) {
         device_name,
         display_name,
         is_active,
-        location (
+        locations (
           id,
           name,
           timezone
@@ -31,7 +34,10 @@ export async function POST(request: NextRequest) {
       .eq('is_active', true)
       .single()
 
+    console.log('Kiosk query result:', { error, kiosk })
+
     if (error || !kiosk) {
+      console.log('Authentication failed:', error || 'Kiosk not found')
       return NextResponse.json(
         { error: 'Invalid API key or kiosk not active' },
         { status: 401 }
@@ -46,7 +52,7 @@ export async function POST(request: NextRequest) {
         device_name: kiosk.device_name,
         display_name: kiosk.display_name,
         is_active: kiosk.is_active,
-        location: kiosk.location
+        location: kiosk.locations
       }
     })
   } catch (error) {

app/api/kiosk/bookings/[shortId]/confirm/route.ts

@@ -1,14 +1,14 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { supabase } from '@/lib/supabase/client'
+import { supabaseAdmin } from '@/lib/supabase/client'
 
 async function validateKiosk(request: NextRequest) {
   const apiKey = request.headers.get('x-kiosk-api-key')
-  
+
   if (!apiKey) {
     return null
   }
 
-  const { data: kiosk } = await supabase
+  const { data: kiosk } = await supabaseAdmin
     .from('kiosks')
     .select('id, location_id, is_active')
     .eq('api_key', apiKey)
@@ -34,7 +34,7 @@ export async function POST(
 
     const shortId = params.shortId
 
-    const { data: booking, error: fetchError } = await supabase
+    const { data: booking, error: fetchError } = await supabaseAdmin
       .from('bookings')
       .select('id, status, location_id')
       .eq('short_id', shortId)
@@ -61,31 +61,11 @@ export async function POST(
       )
     }
 
-    const { data: updatedBooking, error: updateError } = await supabase
+    const { data: updatedBooking, error: updateError } = await supabaseAdmin
       .from('bookings')
       .update({ status: 'confirmed' })
       .eq('id', booking.id)
-      .select(`
-        id,
-        short_id,
-        status,
-        start_time_utc,
-        end_time_utc,
-        service (
-          id,
-          name,
-          duration_minutes
-        ),
-        resource (
-          id,
-          name,
-          type
-        ),
-        staff (
-          id,
-          display_name
-        )
-      `)
+      .select('id, short_id, status, start_time_utc, end_time_utc')
       .single()
 
     if (updateError || !updatedBooking) {

app/api/kiosk/bookings/route.ts

@@ -1,14 +1,14 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { supabase } from '@/lib/supabase/client'
+import { supabaseAdmin } from '@/lib/supabase/client'
 
 async function validateKiosk(request: NextRequest) {
   const apiKey = request.headers.get('x-kiosk-api-key')
-  
+
   if (!apiKey) {
     return null
   }
 
-  const { data: kiosk } = await supabase
+  const { data: kiosk } = await supabaseAdmin
     .from('kiosks')
     .select('id, location_id, is_active')
     .eq('api_key', apiKey)
@@ -33,29 +33,9 @@ export async function GET(request: NextRequest) {
     const short_id = searchParams.get('short_id')
     const date = searchParams.get('date')
 
-    let query = supabase
+    let query = supabaseAdmin
       .from('bookings')
-      .select(`
-        id,
-        short_id,
-        status,
-        start_time_utc,
-        end_time_utc,
-        service (
-          id,
-          name,
-          duration_minutes
-        ),
-        resource (
-          id,
-          name,
-          type
-        ),
-        staff (
-          id,
-          display_name
-        )
-      `)
+      .select()
       .eq('location_id', kiosk.location_id)
       .in('status', ['pending', 'confirmed'])
 
@@ -121,7 +101,7 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const { data: service, error: serviceError } = await supabase
+    const { data: service, error: serviceError } = await supabaseAdmin
       .from('services')
       .select('*')
       .eq('id', service_id)
@@ -139,7 +119,7 @@ export async function POST(request: NextRequest) {
     const endTime = new Date(startTime)
     endTime.setMinutes(endTime.getMinutes() + service.duration_minutes)
 
-    const { data: availableResources } = await supabase
+    const { data: availableResources } = await supabaseAdmin
       .rpc('get_available_resources_with_priority', {
         p_location_id: kiosk.location_id,
         p_start_time: startTime.toISOString(),
@@ -155,7 +135,7 @@ export async function POST(request: NextRequest) {
 
     const assignedResource = availableResources[0]
 
-    const { data: customer, error: customerError } = await supabase
+    const { data: customer, error: customerError } = await supabaseAdmin
       .from('customers')
       .upsert({
         email: customer_email,
@@ -175,7 +155,7 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const { data: booking, error: bookingError } = await supabase
+    const { data: booking, error: bookingError } = await supabaseAdmin
       .from('bookings')
       .insert({
         customer_id: customer.id,
@@ -191,28 +171,7 @@ export async function POST(request: NextRequest) {
         is_paid: false,
         notes
       })
-      .select(`
-        id,
-        short_id,
-        status,
-        start_time_utc,
-        end_time_utc,
-        service (
-          id,
-          name,
-          duration_minutes,
-          base_price
-        ),
-        resource (
-          id,
-          name,
-          type
-        ),
-        staff (
-          id,
-          display_name
-        )
-      `)
+      .select('id, short_id, status, start_time_utc, end_time_utc')
       .single()
 
     if (bookingError || !booking) {
@@ -224,11 +183,10 @@ export async function POST(request: NextRequest) {
 
     return NextResponse.json({
       success: true,
-      booking: {
-        ...booking,
-        resource_name: assignedResource.resource_name,
-        resource_type: assignedResource.resource_type
-      }
+      booking,
+      service_name: service.name,
+      resource_name: assignedResource.resource_name,
+      resource_type: assignedResource.resource_type
     }, { status: 201 })
   } catch (error) {
     console.error('Kiosk bookings POST error:', error)

app/api/kiosk/resources/available/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { supabase } from '@/lib/supabase/client'
+import { supabaseAdmin } from '@/lib/supabase/client'
 
 async function validateKiosk(request: NextRequest) {
   const apiKey = request.headers.get('x-kiosk-api-key')
@@ -8,7 +8,7 @@ async function validateKiosk(request: NextRequest) {
     return null
   }
 
-  const { data: kiosk } = await supabase
+  const { data: kiosk } = await supabaseAdmin
     .from('kiosks')
     .select('id, location_id, is_active')
     .eq('api_key', apiKey)
@@ -51,7 +51,7 @@ export async function GET(request: NextRequest) {
       )
     }
 
-    let resourceQuery = supabase
+    let resourceQuery = supabaseAdmin
       .rpc('get_available_resources_with_priority', {
         p_location_id: kiosk.location_id,
         p_start_time: startTime.toISOString(),
@@ -70,14 +70,14 @@ export async function GET(request: NextRequest) {
     let availableResources = resources || []
 
     if (service_id) {
-      const { data: service } = await supabase
+      const { data: service } = await supabaseAdmin
         .from('services')
         .select('requires_dual_artist')
         .eq('id', service_id)
         .single()
 
       if (service?.requires_dual_artist) {
-        availableResources = availableResources.filter(r => r.resource_type === 'room')
+        availableResources = availableResources.filter((r: any) => r.resource_type === 'room')
       }
     }
 

app/api/kiosk/walkin/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { supabase } from '@/lib/supabase/client'
+import { supabaseAdmin } from '@/lib/supabase/client'
 
 async function validateKiosk(request: NextRequest) {
   const apiKey = request.headers.get('x-kiosk-api-key')
@@ -8,7 +8,7 @@ async function validateKiosk(request: NextRequest) {
     return null
   }
 
-  const { data: kiosk } = await supabase
+  const { data: kiosk } = await supabaseAdmin
     .from('kiosks')
     .select('id, location_id, is_active')
     .eq('api_key', apiKey)
@@ -45,7 +45,7 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const { data: service, error: serviceError } = await supabase
+    const { data: service, error: serviceError } = await supabaseAdmin
       .from('services')
       .select('*')
       .eq('id', service_id)
@@ -59,7 +59,7 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const { data: availableStaff } = await supabase
+    const { data: availableStaff } = await supabaseAdmin
       .from('staff')
       .select('id, display_name, role')
       .eq('location_id', kiosk.location_id)
@@ -79,7 +79,7 @@ export async function POST(request: NextRequest) {
     const endTime = new Date(startTime)
     endTime.setMinutes(endTime.getMinutes() + service.duration_minutes)
 
-    const { data: availableResources } = await supabase
+    const { data: availableResources } = await supabaseAdmin
       .rpc('get_available_resources_with_priority', {
         p_location_id: kiosk.location_id,
         p_start_time: startTime.toISOString(),
@@ -95,7 +95,7 @@ export async function POST(request: NextRequest) {
 
     const assignedResource = availableResources[0]
 
-    const { data: customer, error: customerError } = await supabase
+    const { data: customer, error: customerError } = await supabaseAdmin
       .from('customers')
       .upsert({
         email: customer_email,
@@ -115,7 +115,7 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const { data: booking, error: bookingError } = await supabase
+    const { data: booking, error: bookingError } = await supabaseAdmin
       .from('bookings')
       .insert({
         customer_id: customer.id,
@@ -131,28 +131,7 @@ export async function POST(request: NextRequest) {
         is_paid: false,
         notes: notes ? `${notes} [Walk-in]` : '[Walk-in]'
       })
-      .select(`
-        id,
-        short_id,
-        status,
-        start_time_utc,
-        end_time_utc,
-        service (
-          id,
-          name,
-          duration_minutes,
-          base_price
-        ),
-        resource (
-          id,
-          name,
-          type
-        ),
-        staff (
-          id,
-          display_name
-        )
-      `)
+      .select('id, status, start_time_utc, end_time_utc, total_amount, is_paid')
       .single()
 
     if (bookingError || !booking) {
@@ -164,12 +143,11 @@ export async function POST(request: NextRequest) {
 
     return NextResponse.json({
       success: true,
-      booking: {
-        ...booking,
-        resource_name: assignedResource.resource_name,
-        resource_type: assignedResource.resource_type,
-        staff_name: assignedStaff.display_name
-      },
+      booking,
+      service_name: service.name,
+      resource_name: assignedResource.resource_name,
+      resource_type: assignedResource.resource_type,
+      staff_name: assignedStaff.display_name,
       message: 'Walk-in booking created successfully'
     }, { status: 201 })
   } catch (error) {

app/globals.css

@@ -0,0 +1,27 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+:root {
+  --foreground-rgb: 0, 0, 0;
+  --background-start-rgb: 214, 219, 220;
+  --background-end-rgb: 255, 255, 255;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --foreground-rgb: 255, 255, 255;
+    --background-start-rgb: 0, 0, 0;
+    --background-end-rgb: 0, 0, 0;
+  }
+}
+
+body {
+  color: rgb(var(--foreground-rgb));
+  background: linear-gradient(
+      to bottom,
+      transparent,
+      rgb(var(--background-end-rgb))
+    )
+    rgb(var(--background-start-rgb));
+}

app/layout.tsx

@@ -0,0 +1,22 @@
+import type { Metadata } from 'next'
+import { Inter } from 'next/font/google'
+import './globals.css'
+
+const inter = Inter({ subsets: ['latin'] })
+
+export const metadata: Metadata = {
+  title: 'SalonOS',
+  description: 'Exclusive Studio Management & CRM Engine',
+}
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en">
+      <body className={inter.className}>{children}</body>
+    </html>
+  )
+}

components/kiosk/WalkInFlow.tsx

@@ -24,7 +24,7 @@ export function WalkInFlow({ apiKey, onComplete, onCancel }: WalkInFlowProps) {
     email: '',
     phone: ''
   })
-  const [availableResources, setAvailableResources] = useState<any[]>(null)
+  const [availableResources, setAvailableResources] = useState<any[] | null>(null)
   const [createdBooking, setCreatedBooking] = useState<any>(null)
 
   const loadServices = async () => {

components/ui/badge.tsx

@@ -0,0 +1,36 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const badgeVariants = cva(
+  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default:
+          "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+        secondary:
+          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive:
+          "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+        outline: "text-foreground",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+export interface BadgeProps
+  extends React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return (
+    <div className={cn(badgeVariants({ variant }), className)} {...props} />
+  )
+}
+
+export { Badge, badgeVariants }

package.json

@@ -17,31 +17,36 @@
     "auth:create": "node scripts/create-auth-users.js"
   },
   "dependencies": {
+    "@hookform/resolvers": "^3.3.3",
+    "@radix-ui/react-label": "^2.1.8",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@supabase/auth-helpers-nextjs": "^0.8.7",
+    "@supabase/supabase-js": "^2.38.4",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "date-fns": "^3.0.6",
+    "date-fns-tz": "^2.0.0",
+    "framer-motion": "^10.16.16",
+    "lucide-react": "^0.303.0",
     "next": "14.0.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "@supabase/supabase-js": "^2.38.4",
-    "@supabase/auth-helpers-nextjs": "^0.8.7",
-    "framer-motion": "^10.16.16",
-    "clsx": "^2.0.0",
-    "tailwind-merge": "^2.2.0",
-    "lucide-react": "^0.303.0",
-    "date-fns": "^3.0.6",
-    "date-fns-tz": "^2.0.0",
-    "zod": "^3.22.4",
     "react-hook-form": "^7.49.2",
-    "@hookform/resolvers": "^3.3.3"
+    "tailwind-merge": "^2.6.0",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
-    "typescript": "^5.3.3",
     "@types/node": "^20.10.5",
     "@types/react": "^18.2.45",
     "@types/react-dom": "^18.2.18",
     "autoprefixer": "^10.4.16",
-    "postcss": "^8.4.32",
-    "tailwindcss": "^3.4.0",
+    "dotenv": "^16.3.1",
     "eslint": "^8.56.0",
     "eslint-config-next": "14.0.4",
-    "dotenv": "^16.3.1"
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.4.0",
+    "typescript": "^5.3.3"
   }
 }

supabase/migrations/20260115235737_initial_schema.sql

@@ -552,18 +552,18 @@ CREATE OR REPLACE FUNCTION generate_short_id()
 RETURNS VARCHAR(6) AS $$
 DECLARE
     chars VARCHAR(36) := '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    short_id VARCHAR(6);
+    v_short_id VARCHAR(6);
     attempts INT := 0;
     max_attempts INT := 10;
 BEGIN
     LOOP
-        short_id := '';
+        v_short_id := '';
         FOR i IN 1..6 LOOP
-            short_id := short_id || substr(chars, floor(random() * 36 + 1)::INT, 1);
+            v_short_id := v_short_id || substr(chars, floor(random() * 36 + 1)::INT, 1);
         END LOOP;
 
-        IF NOT EXISTS (SELECT 1 FROM bookings WHERE short_id = short_id) THEN
-            RETURN short_id;
+        IF NOT EXISTS (SELECT 1 FROM bookings WHERE short_id = v_short_id) THEN
+            RETURN v_short_id;
         END IF;
 
         attempts := attempts + 1;

supabase/migrations/20260116000000_add_kiosk_system.sql

@@ -55,18 +55,18 @@ CREATE OR REPLACE FUNCTION generate_kiosk_api_key()
 RETURNS VARCHAR(64) AS $$
 DECLARE
     chars VARCHAR(62) := 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    api_key VARCHAR(64);
+    v_api_key VARCHAR(64);
     attempts INT := 0;
     max_attempts INT := 10;
 BEGIN
     LOOP
-        api_key := '';
+        v_api_key := '';
         FOR i IN 1..64 LOOP
-            api_key := api_key || substr(chars, floor(random() * 62 + 1)::INT, 1);
+            v_api_key := v_api_key || substr(chars, floor(random() * 62 + 1)::INT, 1);
         END LOOP;
 
-        IF NOT EXISTS (SELECT 1 FROM kiosks WHERE api_key = api_key) THEN
-            RETURN api_key;
+        IF NOT EXISTS (SELECT 1 FROM kiosks WHERE api_key = v_api_key) THEN
+            RETURN v_api_key;
         END IF;
 
         attempts := attempts + 1;

supabase/migrations/20260116040000_availability_system.sql

@@ -0,0 +1,52 @@
+-- ============================================
+-- FASE 2.1 - DISPONIBILIDAD DOBLE CAPA (SIMPLIFICADA)
+-- Horarios de staff y validación básica
+-- ============================================
+
+-- ============================================
+-- AGREGAR CAMPOS DE HORARIO A STAFF
+-- ============================================
+
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'staff' AND column_name = 'work_hours_start') THEN
+        ALTER TABLE staff ADD COLUMN work_hours_start TIME;
+        RAISE NOTICE 'Added work_hours_start to staff';
+    END IF;
+
+    IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'staff' AND column_name = 'work_hours_end') THEN
+        ALTER TABLE staff ADD COLUMN work_hours_end TIME;
+        RAISE NOTICE 'Added work_hours_end to staff';
+    END IF;
+
+    IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'staff' AND column_name = 'work_days') THEN
+        ALTER TABLE staff ADD COLUMN work_days TEXT DEFAULT 'MON,TUE,WED,THU,FRI,SAT';
+        RAISE NOTICE 'Added work_days to staff';
+    END IF;
+
+    IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'staff' AND column_name = 'is_available_for_booking') THEN
+        ALTER TABLE staff ADD COLUMN is_available_for_booking BOOLEAN DEFAULT true;
+        RAISE NOTICE 'Added is_available_for_booking to staff';
+    END IF;
+END
+$$;
+
+-- ============================================
+-- VERIFICACIÓN
+-- ============================================
+
+DO $$
+BEGIN
+    RAISE NOTICE '==========================================';
+    RAISE NOTICE 'FASE 2.1 - DISPONIBILIDAD COMPLETADA';
+    RAISE NOTICE '==========================================';
+    RAISE NOTICE 'Campos agregados a staff:';
+    RAISE NOTICE '  - work_hours_start';
+    RAISE NOTICE '  - work_hours_end';
+    RAISE NOTICE '  - work_days';
+    RAISE NOTICE '  - is_available_for_booking';
+    RAISE NOTICE '==========================================';
+    RAISE NOTICE 'Est listo para la Fase 2.2 - Servicios Express';
+    RAISE NOTICE '==========================================';
+END
+$$;

supabase/migrations/20260116050000_fix_short_id_ambiguity.sql

@@ -0,0 +1,29 @@
+-- Fix short_id variable name collision to avoid ambiguous column reference
+-- This migration fixes the issue where the variable name in generate_short_id()
+-- conflicts with the column name in the bookings table
+
+CREATE OR REPLACE FUNCTION generate_short_id()
+RETURNS VARCHAR(6) AS $$
+DECLARE
+    chars VARCHAR(36) := '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    v_short_id VARCHAR(6);
+    attempts INT := 0;
+    max_attempts INT := 10;
+BEGIN
+    LOOP
+        v_short_id := '';
+        FOR i IN 1..6 LOOP
+            v_short_id := v_short_id || substr(chars, floor(random() * 36 + 1)::INT, 1);
+        END LOOP;
+
+        IF NOT EXISTS (SELECT 1 FROM bookings WHERE short_id = v_short_id) THEN
+            RETURN v_short_id;
+        END IF;
+
+        attempts := attempts + 1;
+        IF attempts >= max_attempts THEN
+            RAISE EXCEPTION 'Failed to generate unique short_id after % attempts', max_attempts;
+        END IF;
+    END LOOP;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;

supabase/migrations/20260116060000_fix_availability_timezone.sql

@@ -0,0 +1,183 @@
+-- ============================================
+-- FIX: Corregir funciones de disponibilidad para considerar zona horaria
+-- ============================================
+
+-- Eliminar funciones antiguas que no consideran zona horaria
+DROP FUNCTION IF EXISTS check_staff_work_hours(UUID, TIMESTAMPTZ, TIMESTAMPTZ);
+DROP FUNCTION IF EXISTS check_staff_availability(UUID, TIMESTAMPTZ, TIMESTAMPTZ, UUID);
+DROP FUNCTION IF EXISTS check_resource_availability(UUID, TIMESTAMPTZ, TIMESTAMPTZ, UUID);
+DROP FUNCTION IF EXISTS get_available_staff(UUID, TIMESTAMPTZ, TIMESTAMPTZ, UUID, UUID);
+
+-- Recrear check_staff_work_hours con soporte de zona horaria
+CREATE OR REPLACE FUNCTION check_staff_work_hours(
+    p_staff_id UUID,
+    p_start_time_utc TIMESTAMPTZ,
+    p_end_time_utc TIMESTAMPTZ,
+    p_location_timezone TEXT
+)
+RETURNS BOOLEAN AS $$
+DECLARE
+    v_staff_record RECORD;
+    v_start_time TIME;
+    v_end_time TIME;
+    v_work_days TEXT;
+    v_day_of_week INTEGER;
+    v_start_local TIMESTAMPTZ;
+    v_end_local TIMESTAMPTZ;
+BEGIN
+    SELECT * INTO v_staff_record
+    FROM staff
+    WHERE id = p_staff_id;
+
+    IF NOT FOUND THEN
+        RETURN false;
+    END IF;
+
+    IF NOT v_staff_record.is_active THEN
+        RETURN false;
+    END IF;
+
+    IF NOT v_staff_record.is_available_for_booking THEN
+        RETURN false;
+    END IF;
+
+    -- Convertir UTC a hora local de la ubicación
+    v_start_local := p_start_time_utc AT TIME ZONE p_location_timezone;
+    v_end_local := p_end_time_utc AT TIME ZONE p_location_timezone;
+
+    v_start_time := v_start_local::TIME;
+    v_end_time := v_end_local::TIME;
+    v_work_days := v_staff_record.work_days;
+
+    v_day_of_week := EXTRACT(ISODOW FROM v_start_local);
+
+    IF v_work_days IS NULL THEN
+        RETURN true;
+    END IF;
+
+    IF v_day_of_week = 1 AND v_work_days LIKE '%MON%' THEN RETURN true; END IF;
+    IF v_day_of_week = 2 AND v_work_days LIKE '%TUE%' THEN RETURN true; END IF;
+    IF v_day_of_week = 3 AND v_work_days LIKE '%WED%' THEN RETURN true; END IF;
+    IF v_day_of_week = 4 AND v_work_days LIKE '%THU%' THEN RETURN true; END IF;
+    IF v_day_of_week = 5 AND v_work_days LIKE '%FRI%' THEN RETURN true; END IF;
+    IF v_day_of_week = 6 AND v_work_days LIKE '%SAT%' THEN RETURN true; END IF;
+    IF v_day_of_week = 7 AND v_work_days LIKE '%SUN%' THEN RETURN true; END IF;
+
+    -- Verificar que el tiempo esté dentro del horario laboral
+    IF v_start_time < v_staff_record.work_hours_start OR
+       v_end_time > v_staff_record.work_hours_end THEN
+        RETURN false;
+    END IF;
+
+    RETURN true;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+
+-- Recrear check_staff_availability con soporte de zona horaria
+CREATE OR REPLACE FUNCTION check_staff_availability(
+    p_staff_id UUID,
+    p_start_time_utc TIMESTAMPTZ,
+    p_end_time_utc TIMESTAMPTZ,
+    p_exclude_booking_id UUID DEFAULT NULL
+)
+RETURNS BOOLEAN AS $$
+DECLARE
+    v_is_work_hours BOOLEAN;
+    v_has_booking_conflict BOOLEAN;
+    v_has_manual_block BOOLEAN;
+    v_location_timezone TEXT;
+BEGIN
+    -- Obtener zona horaria de la ubicación del staff
+    SELECT timezone INTO v_location_timezone
+    FROM locations
+    WHERE id = (SELECT location_id FROM staff WHERE id = p_staff_id);
+
+    v_is_work_hours := check_staff_work_hours(p_staff_id, p_start_time_utc, p_end_time_utc, v_location_timezone);
+
+    IF NOT v_is_work_hours THEN
+        RETURN false;
+    END IF;
+
+    -- Verificar conflictos con eventos de calendario
+    SELECT EXISTS(
+        SELECT 1
+        FROM google_calendar_events
+        WHERE staff_id = p_staff_id
+        AND is_blocking = true
+        AND NOT (p_end_time_utc <= start_time_utc OR p_start_time_utc >= end_time_utc)
+    ) INTO v_has_booking_conflict;
+
+    IF v_has_booking_conflict THEN
+        RETURN false;
+    END IF;
+
+    -- Verificar conflictos con otras reservas
+    SELECT EXISTS(
+        SELECT 1
+        FROM bookings
+        WHERE staff_id = p_staff_id
+        AND status NOT IN ('cancelled', 'no_show')
+        AND (p_exclude_booking_id IS NULL OR id != p_exclude_booking_id)
+        AND NOT (p_end_time_utc <= start_time_utc OR p_start_time_utc >= end_time_utc)
+    ) INTO v_has_manual_block;
+
+    IF v_has_manual_block THEN
+        RETURN false;
+    END IF;
+
+    -- Verificar bloques manuales de disponibilidad
+    SELECT EXISTS(
+        SELECT 1
+        FROM staff_availability
+        WHERE staff_id = p_staff_id
+        AND date = (p_start_time_utc AT TIME ZONE v_location_timezone)::DATE
+        AND is_available = false
+        AND NOT (p_end_time_utc AT TIME ZONE v_location_timezone::TIME <= start_time
+               OR p_start_time_utc AT TIME ZONE v_location_timezone::TIME >= end_time)
+    ) INTO v_has_manual_block;
+
+    IF v_has_manual_block THEN
+        RETURN false;
+    END IF;
+
+    RETURN true;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+
+-- Recrear get_available_staff simplificado
+CREATE OR REPLACE FUNCTION get_available_staff(
+    p_location_id UUID,
+    p_start_time_utc TIMESTAMPTZ,
+    p_end_time_utc TIMESTAMPTZ
+)
+RETURNS TABLE (
+    staff_id UUID,
+    staff_name TEXT,
+    role TEXT,
+    work_hours_start TIME,
+    work_hours_end TIME,
+    work_days TEXT
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT
+        s.id::UUID,
+        s.display_name::TEXT,
+        s.role::TEXT,
+        s.work_hours_start::TIME,
+        s.work_hours_end::TIME,
+        s.work_days::TEXT
+    FROM staff s
+    WHERE s.location_id = p_location_id
+    AND s.is_active = true
+    AND s.is_available_for_booking = true
+    AND s.role IN ('artist', 'staff', 'manager')
+    AND check_staff_availability(s.id, p_start_time_utc, p_end_time_utc)
+    ORDER BY
+        CASE s.role
+            WHEN 'manager' THEN 1
+            WHEN 'staff' THEN 2
+            WHEN 'artist' THEN 3
+        END;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;

supabase/migrations/20260116070000_fix_staff_return_types.sql

@@ -0,0 +1,42 @@
+-- ============================================
+-- FIX: Corregir función get_available_staff con tipos correctos
+-- ============================================
+
+DROP FUNCTION IF EXISTS get_available_staff(UUID, TIMESTAMPTZ, TIMESTAMPTZ);
+
+CREATE OR REPLACE FUNCTION get_available_staff(
+    p_location_id UUID,
+    p_start_time_utc TIMESTAMPTZ,
+    p_end_time_utc TIMESTAMPTZ
+)
+RETURNS TABLE (
+    staff_id UUID,
+    staff_name TEXT,
+    role TEXT,
+    work_hours_start TIME,
+    work_hours_end TIME,
+    work_days TEXT
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT
+        s.id::UUID,
+        s.display_name::TEXT,
+        s.role::TEXT,
+        s.work_hours_start::TIME,
+        s.work_hours_end::TIME,
+        s.work_days::TEXT
+    FROM staff s
+    WHERE s.location_id = p_location_id
+    AND s.is_active = true
+    AND s.is_available_for_booking = true
+    AND s.role IN ('artist', 'staff', 'manager')
+    AND check_staff_availability(s.id, p_start_time_utc, p_end_time_utc)
+    ORDER BY
+        CASE s.role
+            WHEN 'manager' THEN 1
+            WHEN 'staff' THEN 2
+            WHEN 'artist' THEN 3
+        END;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;

supabase/migrations/20260116080000_fix_availability_missing_tables.sql

@@ -0,0 +1,79 @@
+-- ============================================
+-- FIX: Actualizar check_staff_availability para ignorar google_calendar_events si no existe
+-- ============================================
+
+DROP FUNCTION IF EXISTS check_staff_availability(UUID, TIMESTAMPTZ, TIMESTAMPTZ, UUID);
+
+CREATE OR REPLACE FUNCTION check_staff_availability(
+    p_staff_id UUID,
+    p_start_time_utc TIMESTAMPTZ,
+    p_end_time_utc TIMESTAMPTZ,
+    p_exclude_booking_id UUID DEFAULT NULL
+)
+RETURNS BOOLEAN AS $$
+DECLARE
+    v_is_work_hours BOOLEAN;
+    v_has_booking_conflict BOOLEAN;
+    v_has_manual_block BOOLEAN;
+    v_location_timezone TEXT;
+BEGIN
+    -- Obtener zona horaria de la ubicación del staff
+    SELECT timezone INTO v_location_timezone
+    FROM locations
+    WHERE id = (SELECT location_id FROM staff WHERE id = p_staff_id);
+
+    v_is_work_hours := check_staff_work_hours(p_staff_id, p_start_time_utc, p_end_time_utc, v_location_timezone);
+
+    IF NOT v_is_work_hours THEN
+        RETURN false;
+    END IF;
+
+    -- Verificar conflictos con eventos de calendario solo si la tabla existe
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'google_calendar_events') THEN
+        SELECT EXISTS(
+            SELECT 1
+            FROM google_calendar_events
+            WHERE staff_id = p_staff_id
+            AND is_blocking = true
+            AND NOT (p_end_time_utc <= start_time_utc OR p_start_time_utc >= end_time_utc)
+        ) INTO v_has_booking_conflict;
+
+        IF v_has_booking_conflict THEN
+            RETURN false;
+        END IF;
+    END IF;
+
+    -- Verificar conflictos con otras reservas
+    SELECT EXISTS(
+        SELECT 1
+        FROM bookings
+        WHERE staff_id = p_staff_id
+        AND status NOT IN ('cancelled', 'no_show')
+        AND (p_exclude_booking_id IS NULL OR id != p_exclude_booking_id)
+        AND NOT (p_end_time_utc <= start_time_utc OR p_start_time_utc >= end_time_utc)
+    ) INTO v_has_manual_block;
+
+    IF v_has_manual_block THEN
+        RETURN false;
+    END IF;
+
+    -- Verificar bloques manuales de disponibilidad
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'staff_availability') THEN
+        SELECT EXISTS(
+            SELECT 1
+            FROM staff_availability
+            WHERE staff_id = p_staff_id
+            AND date = (p_start_time_utc AT TIME ZONE v_location_timezone)::DATE
+            AND is_available = false
+            AND NOT (p_end_time_utc AT TIME ZONE v_location_timezone::TIME <= start_time
+                   OR p_start_time_utc AT TIME ZONE v_location_timezone::TIME >= end_time)
+        ) INTO v_has_manual_block;
+
+        IF v_has_manual_block THEN
+            RETURN false;
+        END IF;
+    END IF;
+
+    RETURN true;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;

supabase/migrations/20260116090000_add_detailed_availability.sql

@@ -0,0 +1,73 @@
+-- ============================================
+-- Crear función get_detailed_availability para obtener slots de tiempo
+-- ============================================
+
+CREATE OR REPLACE FUNCTION get_detailed_availability(
+    p_location_id UUID,
+    p_service_id UUID,
+    p_date DATE,
+    p_time_slot_duration_minutes INTEGER DEFAULT 60
+)
+RETURNS JSONB AS $$
+DECLARE
+    v_service_duration INTEGER;
+    v_location_timezone TEXT;
+    v_start_time TIME := '09:00'::TIME;
+    v_end_time TIME := '21:00'::TIME;
+    v_time_slots JSONB := '[]'::JSONB;
+    v_slot_start TIMESTAMPTZ;
+    v_slot_end TIMESTAMPTZ;
+    v_available_staff_count INTEGER;
+BEGIN
+    -- Obtener duración del servicio
+    SELECT duration_minutes INTO v_service_duration
+    FROM services
+    WHERE id = p_service_id;
+
+    IF v_service_duration IS NULL THEN
+        RETURN '[]'::JSONB;
+    END IF;
+
+    -- Obtener zona horaria de la ubicación
+    SELECT timezone INTO v_location_timezone
+    FROM locations
+    WHERE id = p_location_id;
+
+    -- Generar slots de tiempo para el día
+    v_slot_start := (p_date || ' ' || v_start_time::TEXT)::TIMESTAMPTZ
+        AT TIME ZONE v_location_timezone;
+
+    v_slot_end := (p_date || ' ' || v_end_time::TEXT)::TIMESTAMPTZ
+        AT TIME ZONE v_location_timezone;
+
+    -- Iterar por cada slot
+    WHILE v_slot_start < v_slot_end LOOP
+        -- Verificar staff disponible para este slot
+        SELECT COUNT(*) INTO v_available_staff_count
+        FROM (
+            SELECT 1
+            FROM staff s
+            WHERE s.location_id = p_location_id
+            AND s.is_active = true
+            AND s.is_available_for_booking = true
+            AND s.role IN ('artist', 'staff', 'manager')
+            AND check_staff_availability(s.id, v_slot_start, v_slot_start + (v_service_duration || ' minutes')::INTERVAL)
+        ) AS available_staff;
+
+        -- Agregar slot al resultado
+        IF v_available_staff_count > 0 THEN
+            v_time_slots := v_time_slots || jsonb_build_object(
+                'start_time', v_slot_start::TEXT,
+                'end_time', (v_slot_start + (p_time_slot_duration_minutes || ' minutes')::INTERVAL)::TEXT,
+                'available', true,
+                'available_staff_count', v_available_staff_count
+            );
+        END IF;
+
+        -- Avanzar al siguiente slot
+        v_slot_start := v_slot_start + (p_time_slot_duration_minutes || ' minutes')::INTERVAL;
+    END LOOP;
+
+    RETURN v_time_slots;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;