import * as i0 from '@angular/core';

/**
 * Interface que define los tipos de valores de fecha aceptados por el sistema
 * Soporta múltiples formatos de entrada para máxima flexibilidad
 */
interface DateValue {
    /** Valor de fecha en cualquier formato soportado */
    value: string | Date | number;
    /** Formato específico del valor de entrada (opcional) */
    format?: 'dd-MM-yyyy' | 'dd/MM/yyyy' | 'MM/dd/yyyy' | 'yyyy-MM-dd' | 'iso' | 'timestamp';
    /** Zona horaria específica para el valor (opcional) */
    timezone?: string;
}

/**
 * Interface de configuración para el componente DateDisplayComponent
 * Permite personalizar la visualización de fechas según el contexto
 */
interface DateDisplayConfig {
    /** Mostrar indicador de zona horaria cuando difiere del usuario */
    showTimezone?: boolean;
    /** Formato de visualización de la fecha */
    format?: 'dd/MM/yyyy' | 'MM/dd/yyyy' | 'yyyy-MM-dd';
    /** Contexto de uso para aplicar estilos apropiados */
    context?: 'form' | 'table' | 'inline';
    /** Configuración de locale para formateo */
    locale?: string;
}

/**
 * Interface que representa una fecha parseada en sus componentes individuales
 * Utilizada por el parser ISO 8601 para estructurar la información de fecha
 */
interface ParsedDate {
    /** Año (4 dígitos) */
    year: number;
    /** Mes (1-12) */
    month: number;
    /** Día del mes (1-31) */
    day: number;
    /** Hora (0-23) - opcional para fechas sin tiempo */
    hour?: number;
    /** Minutos (0-59) - opcional para fechas sin tiempo */
    minute?: number;
    /** Segundos (0-59) - opcional para fechas sin tiempo */
    second?: number;
    /** Milisegundos (0-999) - opcional */
    millisecond?: number;
    /** Información de zona horaria - opcional */
    timezoneOffset?: {
        /** Signo del offset (+ o -) */
        sign: '+' | '-';
        /** Horas del offset (0-14) */
        hours: number;
        /** Minutos del offset (0-59) */
        minutes: number;
    };
}

/**
 * Interface que define la estructura de errores relacionados con fechas
 * Proporciona información detallada para debugging y manejo de errores
 */
interface DateError {
    /** Tipo específico de error */
    type: 'INVALID_FORMAT' | 'INVALID_DATE' | 'INVALID_TIMEZONE' | 'PARSE_ERROR';
    /** Mensaje descriptivo del error */
    message: string;
    /** Posición del error en la cadena de entrada (opcional) */
    position?: number;
    /** Valor de entrada que causó el error (opcional) */
    input?: string;
}

/**
 * Enum que define los tipos de errores posibles en operaciones de fecha
 */
declare enum DateErrorType {
    /** Error de formato inválido */
    INVALID_FORMAT = "INVALID_FORMAT",
    /** Error de fecha inválida (ej: 31 de febrero) */
    INVALID_DATE = "INVALID_DATE",
    /** Error de zona horaria inválida */
    INVALID_TIMEZONE = "INVALID_TIMEZONE",
    /** Error general de parsing */
    PARSE_ERROR = "PARSE_ERROR",
    /** Advertencia de performance */
    PERFORMANCE_WARNING = "PERFORMANCE_WARNING"
}

/**
 * Enum que define los formatos de fecha soportados por el sistema
 */
declare enum DateFormat {
    /** Formato día-mes-año con guiones */
    DD_MM_YYYY_DASH = "dd-MM-yyyy",
    /** Formato día/mes/año con barras */
    DD_MM_YYYY_SLASH = "dd/MM/yyyy",
    /** Formato mes/día/año con barras (formato US) */
    MM_DD_YYYY_SLASH = "MM/dd/yyyy",
    /** Formato año-mes-día con guiones (ISO básico) */
    YYYY_MM_DD_DASH = "yyyy-MM-dd",
    /** Formato ISO 8601 completo */
    ISO = "iso",
    /** Timestamp numérico */
    TIMESTAMP = "timestamp"
}

/**
 * Enum que define los contextos de visualización para el componente DateDisplay
 */
declare enum DisplayContext {
    /** Contexto de formulario */
    FORM = "form",
    /** Contexto de tabla/grid */
    TABLE = "table",
    /** Contexto inline/texto */
    INLINE = "inline"
}

declare class DateTimeUtil {
    private readonly userTimezone;
    constructor();
    /**
     * Verifica si la configuración de timezone ya está en localStorage
     * Usado en APP_INITIALIZER para evitar consultas duplicadas
     */
    isTimezoneConfigLoaded(): boolean;
    /**
     * Guarda la configuración de timezone en localStorage
     * Llamado por Shell y por MF cuando corre standalone
     */
    setTimezoneConfig(defaultTZ: string, timezoneLabel: string): void;
    /**
     * Obtiene la timezone IANA del back (ej: "America/Santiago")
     * Si no está configurada, retorna el fallback
     */
    getDefaultTZ(): string;
    /**
     * Obtiene el label base del timezone del back (ej: "Hora de Chile")
     * Si no está configurado, retorna el fallback
     */
    private getTimezoneBaseLabel;
    /**
     * Construye el label completo del flag de timezone
     * Ejemplo: "Hora de Chile" + "UTC-4" → "Hora de Chile (UTC-4)"
     * Retorna string vacío si isoString es null/undefined
     */
    getTimezoneLabel(isoString: string | null | undefined): string;
    /**
     * Convierte cualquier formato de entrada a ISO 8601.
     * type explícito SIEMPRE tiene prioridad sobre attributeName.
     */
    toISO(value: string | Date | number | DateValue, type?: 'date' | 'datetime', attributeName?: string): string | DateError;
    /**
     * Convierte ISO a dd/MM/yyyy para mostrar en pantalla.
     * Retorna DateError si el string es inválido — nunca silencia errores.
     */
    toDisplay(isoString: string): string | DateError;
    /**
     * Convierte ISO a dd/MM/yyyy HH:mm para mostrar en pantalla con hora.
     * Retorna DateError si el string es inválido — nunca silencia errores.
     */
    toDisplayWithTime(isoString: string): string | DateError;
    /**
     * Convierte ISO a dd/MM/yyyy o dd/MM/yyyy HH:mm automáticamente.
     * Muestra hora solo si la timezone del backend difiere de la del usuario.
     * Retorna DateError si el string es inválido — nunca silencia errores.
     */
    toDisplayAuto(isoString: string): string | DateError;
    /**
     * Extrae el offset ±HH:MM del ISO string.
     */
    getTimezoneOffset(isoString: string | null | undefined): string | null;
    /**
     * Convierte offset ±HH:MM a formato legible "UTC-4".
     */
    getBackendOffset(isoString: string | null | undefined): string;
    /**
     * Compara timezone del ISO (back) con la del usuario (browser).
     * true = misma zona → no mostrar flag
     * false = diferente → mostrar flag
     */
    isSameTimezone(isoString: string | null | undefined): boolean;
    /**
     * Convierte ISO a Date object para pintarlo en MatDatepicker.
     *
     * IMPORTANTE: Extrae componentes directamente del ISO string sin ajuste de timezone.
     * Esto garantiza que:
     * - El picker muestra la fecha correcta (ej: 30/12/1993)
     * - getDate() devuelve el día correcto al guardar (ej: 30)
     * - No hay cambio de día por diferencia de timezone entre backend y usuario
     *
     * Ejemplo:
     * - ISO: "1993-12-30T00:00:00.000-04:00" (Chile UTC-4)
     * - parsed.day = 30
     * - new Date(1993, 11, 30, 0, 0, 0, 0) → picker muestra 30/12/1993 ✅
     * - date.getDate() → 30 siempre ✅
     */
    toDateObject(isoString: string): Date | DateError;
    /**
     * Convierte ISO 8601 a Date object para MatDatepicker, garantizando que muestre la fecha exacta del backend.
     *
     * IMPORTANTE: Ahora que toDateObject() extrae componentes directamente del ISO string,
     * este método simplemente delega a toDateObject() sin necesidad de ajustes adicionales.
     *
     * @param isoString ISO 8601 con offset (ej: "2026-05-20T00:00:00.000-04:00")
     * @returns Date object que se mostrará correctamente en MatDatepicker
     */
    toDateObjectForDatepicker(isoString: string): Date | DateError;
    /**
     * Convierte el Date object del MatDatepicker a ISO 8601.
     * NUNCA usa hora actual — extrae exactamente lo que trae el Date object.
     */
    fromDatepicker(dateValue: Date | string, type: 'date' | 'datetime', attributeName?: string): string | DateError;
    /**
     * Convierte Date del datepicker a ISO datetime con T00:00:00.000
     * para campos date-only que el backend espera como datetime.
     *
     * Extrae año/mes/día directamente sin setHours() para evitar
     * cambio de día por ajuste de timezone.
     *
     * Uso: birthDate, initialDate, endDate (campos que tienen "Date" en el nombre
     * pero el backend espera datetime con offset)
     *
     * @param dateValue Date object del datepicker
     * @returns ISO string con formato "YYYY-MM-DDTHH:mm:ss.sssZ±HH:mm"
     */
    fromDatepickerDateOnly(dateValue: Date): string | DateError;
    /**
     * Infiere 'date' o 'datetime' desde el sufijo del nombre del atributo.
     */
    inferTypeFromAttributeName(attributeName: string): 'date' | 'datetime' | null;
    /**
     * Infiere la regla de hora automática para campos de vigencia.
     * Solo INFORMA la regla — el componente de negocio aplica la hora.
     *
     * 'start'   → usar T00:00:00.000 (inicio del día)
     * 'end'     → usar T23:59:59.999 (fin del día)
     * 'preserve'→ usar la hora que viene en el input
     */
    inferTimeRule(attributeName: string): 'start' | 'end' | 'preserve';
    /**
     * Convierte valor del formulario/datepicker a ISO 8601.
     * Aplica reglas automáticas según el nombre del atributo:
     * - Start → hora actual si es hoy, 00:00 si es futuro
     * - End   → 23:59:59.999
     * - Otros → preservar hora del input
     *
     * Centralizado aquí para no duplicar en cada componente/MF.
     *
     * @param dateValue Valor del datepicker (Date o string)
     * @param type 'date' o 'datetime'
     * @param attributeName Nombre del atributo (para inferir regla de hora)
     * @returns ISO string con offset del backend, o undefined si inválido
     */
    /**
     * Parsea un string en formato dd/MM/yyyy a Date object
     * @param dateString String en formato dd/MM/yyyy
     * @returns Date object o null si no es válido
     */
    private parseDdMmYyyy;
    convertDateToISO(dateValue: any, type: 'date' | 'datetime', attributeName?: string): string | undefined;
    /**
     * Para campos effectiveStartDateTime:
     * - Hoy → hora actual en TZ del back (no del usuario)
     * - Futuro → 00:00:00.000 en TZ del back
     *
     * @param selectedDate Fecha seleccionada por el usuario
     * @returns ISO string con offset del backend o DateError
     */
    fromDatepickerEffectiveStart(selectedDate: Date): string | DateError;
    private parseAny;
    private parseComponents;
    private formatISO;
    private currentUserOffset;
    /**
     * Obtiene la fecha actual expresada en la timezone del backend.
     * Usar para calcular estado de vigencia (activo/inactivo).
     * @param {string} backIsoSample - Valor ISO de ejemplo del backend (contiene el offset)
     * @returns {Date} Fecha actual en la timezone del backend
     */
    getNowInBackTimezone(isoSample?: string): Date;
    /**
     * Construye headers dinámicos con timezone para columnas de vigencia.
     * Muta las columnas existentes sin reemplazar el array.
     * Solo ejecuta si la timezone del backend es diferente a la del usuario.
     * @param {any[]} columns - Array de columnas
     * @param {string} backendIsoSample - Primer valor ISO de una columna de vigencia
     */
    buildTableHeaders(columns: any[], backendIsoSample: string): void;
    /**
     * Elimina tags HTML de un string.
     * @param {string} html - String con HTML
     * @returns {string} String sin HTML
     */
    private stripHtml;
    private err;
    private getDefaultTZOffset;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeUtil, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateTimeUtil>;
}

/**
 * Type guard para verificar si un objeto es DateError
 * @param obj Objeto a verificar
 * @returns true si es DateError, false en caso contrario
 */
declare function isDateError(obj: any): obj is DateError;

/**
 * Clase para parsing y formateo de fechas ISO 8601 con validación completa
 * Implementa validación estricta de formato y rangos de timezone
 */

declare class ISO8601Parser {
    /**
     * Regex para validación completa de formato ISO 8601
     * Soporta:
     * - Fecha sola: YYYY-MM-DD
     * - Fecha con tiempo: YYYY-MM-DDTHH:mm:ss
     * - Con milisegundos: YYYY-MM-DDTHH:mm:ss.sss
     * - Con timezone: Z o ±HH:MM
     */
    private static readonly ISO_REGEX;
    /**
     * Rangos válidos para componentes de fecha
     */
    private static readonly VALID_RANGES;
    /**
     * Días por mes (considerando año bisiesto)
     */
    private static readonly DAYS_IN_MONTH;
    /**
     * Parsea una cadena ISO 8601 en sus componentes estructurados
     * @param isoString Cadena en formato ISO 8601
     * @returns ParsedDate si es válida, DateError si hay errores
     */
    static parse(isoString: string): ParsedDate | DateError;
    /**
     * Formatea un objeto ParsedDate de vuelta a cadena ISO 8601
     * @param parsedDate Objeto con componentes de fecha estructurados
     * @returns Cadena ISO 8601 válida
     */
    static format(parsedDate: ParsedDate): string;
    /**
     * Obtiene el número máximo de días en un mes considerando años bisiestos
     */
    private static getMaxDaysInMonth;
    /**
     * Determina si un año es bisiesto
     */
    private static isLeapYear;
    /**
     * Valida el offset de timezone según los rangos permitidos (-12:00 a +14:00)
     */
    private static validateTimezoneOffset;
    /**
     * Verifica si un valor es un número válido
     */
    private static isValidNumber;
}

export { DateErrorType, DateFormat, DateTimeUtil, DisplayContext, ISO8601Parser, isDateError };
export type { DateDisplayConfig, DateError, DateValue, ParsedDate };