// Tipos de justAlerts 3.0 · https://www.dnmjustme.x10.mx/justAlerts/
// La librería se exporta con module.exports, por eso se declara con `export =`
// (con esModuleInterop también funciona `import justAlerts from "justalerts"`).

declare namespace justAlerts {
  // ------------------------------------------------------------------
  // Toasts
  // ------------------------------------------------------------------
  type ToastType = "success" | "danger" | "warning" | "info" | "loading";
  type AlertType = "success" | "danger" | "warning" | "info";
  type Position =
    | "top-left" | "top-center" | "top-right"
    | "bottom-left" | "bottom-center" | "bottom-right";
  type Theme = "light" | "dark" | "auto";
  type Lang = "es" | "en" | "auto";

  interface ToastAction {
    /** Button text, e.g. "Undo". */
    label: string;
    /** Runs on click. Return `false` to keep the toast open. */
    onClick?: (toast: ToastHandle) => unknown;
  }

  interface ToastOptions {
    /** Default: "info". "loading" shows a spinner and never auto-closes. */
    type?: ToastType;
    /** Optional bold title (plain text). */
    title?: string;
    /** Toast text. Escaped unless `html` is true. A DOM node is also accepted. */
    message?: string | Node;
    /** Default: "top-right". */
    position?: Position;
    /** Visible milliseconds; 0 = never closes on its own. Default: 5000. */
    duration?: number;
    /** Extra pixels from the screen edge. Default: 0. */
    offset?: number;
    /** Treat `message` as HTML. Only for trusted content. Default: false. */
    html?: boolean;
    /** Pause the timer on hover or focus. Default: true. */
    pauseOnHover?: boolean;
    /** Show the time-left bar. Default: true. */
    progress?: boolean;
    /** Action button inside the toast. */
    action?: ToastAction | null;
    /** Default: "light". */
    theme?: Theme;
    /** Language of the built-in texts. Default: "auto" (from <html lang>). */
    lang?: Lang;
  }
  /** v2 name of ToastOptions. */
  type Options = ToastOptions;

  interface ToastHandle {
    id: string | null;
    element: HTMLElement | null;
    close(): void;
    /** Change the open toast (type, title, message, duration, action...). */
    update(next: ToastOptions | string): ToastHandle;
  }
  /** v2 name of ToastHandle. */
  type Handle = ToastHandle;

  interface PromiseMessages<T> {
    loading?: string;
    success?: string | ((value: T) => string);
    error?: string | ((error: any) => string);
    loadingTitle?: string;
    successTitle?: string;
    errorTitle?: string;
  }

  // ------------------------------------------------------------------
  // Modals
  // ------------------------------------------------------------------
  type ModalType = "success" | "danger" | "warning" | "info" | "question";
  type ButtonStyle = "primary" | "secondary" | "danger" | "success" | "ghost";
  type ModalAction = "confirm" | "deny" | "cancel" | "close" | "esc" | "backdrop" | "timer";

  interface ButtonOptions {
    text?: string;
    style?: ButtonStyle;
    className?: string;
  }
  /** `true` = default text, `false` = hidden, a string = custom text. */
  type Button = boolean | string | ButtonOptions;

  type FieldType =
    | "text" | "email" | "password" | "number" | "tel" | "url" | "search"
    | "date" | "time" | "datetime-local" | "month" | "week" | "color"
    | "textarea" | "select" | "radio" | "checkboxes" | "checkbox" | "range" | "file";

  type FieldOptions =
    | Array<string | number | { value: string | number; label?: string }>
    | Record<string, string>;

  type ValidationResult = true | string | void | null;

  interface Field {
    /** Key in the resulting values object. */
    name: string;
    /** Default: "text". */
    type?: FieldType;
    label?: string;
    placeholder?: string;
    /** Initial value (array for checkboxes / multiple select). */
    value?: any;
    /** Initial state of a single checkbox. */
    checked?: boolean;
    required?: boolean;
    min?: number | string;
    max?: number | string;
    step?: number | string;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    /** For select, radio and checkboxes. */
    options?: FieldOptions;
    /** Small help text under the field. */
    hint?: string;
    /** "half" puts two fields per row. */
    width?: "full" | "half";
    /** Textarea rows. Default: 4. */
    rows?: number;
    multiple?: boolean;
    /** File types for type "file", e.g. "image/*". */
    accept?: string;
    /** Image previews for type "file". Default: true. */
    preview?: boolean;
    /** Suffix shown next to a range value, e.g. "%". */
    unit?: string;
    autocomplete?: string;
    inputmode?: string;
    disabled?: boolean;
    readonly?: boolean;
    className?: string;
    /** Extra attributes for the control. */
    attrs?: Record<string, string>;
    /** Custom validation after the native one: true/undefined if valid, or an error message. May be async. */
    validate?: (value: any, values: Record<string, any>) => ValidationResult | Promise<ValidationResult>;
  }

  interface ModalImage {
    src: string;
    alt?: string;
    width?: number | string;
    height?: number | string;
  }

  interface CloseOptions {
    /** Close with the Escape key. Default: true. */
    esc?: boolean;
    /** Close by clicking outside. Default: true. */
    backdrop?: boolean;
    /** Show the × button. Default: true. */
    button?: boolean;
  }

  type FormValidationResult = ValidationResult | Record<string, string>;

  interface ModalOptions {
    /** Animated icon. */
    type?: ModalType | null;
    /** false hides the icon. Default: true. */
    icon?: boolean;
    title?: string;
    /** Plain text (escaped). */
    text?: string;
    /** Trusted HTML or a DOM node; replaces `text`. */
    html?: string | Node | null;
    image?: string | ModalImage | null;
    /** Default: true. */
    confirm?: Button;
    /** Third button ("No"). Default: false. */
    deny?: Button;
    /** Default: false (true in confirm, prompt and form). */
    cancel?: Button;
    reverseButtons?: boolean;
    /** A single field: its value is the result. */
    input?: FieldType | Partial<Field> | null;
    /** A whole form: field list, <form>/<template> element, "#selector" or trusted HTML. */
    form?: Field[] | HTMLElement | string | null;
    /** Validates the whole form: true, a message, or { field: "message" }. May be async. */
    validate?: ((value: any, modal: ModalController) => FormValidationResult | Promise<FormValidationResult>) | null;
    /**
     * Runs on confirm with a loading button. Return a value to resolve with it, `false` to keep
     * the modal open, or throw to show the error message inside the modal.
     */
    onConfirm?: ((value: any, modal: ModalController) => any) | null;
    /** Return false to keep the modal open. */
    onDeny?: ((value: any, modal: ModalController) => any) | null;
    onOpen?: ((modal: ModalController) => void) | null;
    onClose?: ((result: ModalResult) => void) | null;
    /** Confirm button text while onConfirm is running. */
    loadingText?: string | null;
    /** Auto-close after these milliseconds (action "timer"). Default: 0. */
    timer?: number;
    /** Show the timer bar. Default: true. */
    progress?: boolean;
    /** Pause the timer on hover. Default: true. */
    pauseOnHover?: boolean;
    /** Default: true. */
    close?: boolean | CloseOptions;
    /** sm (360), md (460), lg (640), xl (860) or pixels. Default: "md". */
    size?: "sm" | "md" | "lg" | "xl" | number;
    /** Default: "center". */
    align?: "center" | "top";
    /** Element focused on open. Default: the first field or the confirm button. */
    focus?: "confirm" | "cancel" | "deny" | "input" | null;
    className?: string;
    theme?: Theme | null;
    lang?: Lang | null;
  }

  interface ModalResult<V = any> {
    /** true only when the confirm button was used. */
    confirmed: boolean;
    action: ModalAction;
    /** Field value, form values object, onConfirm result, or true. */
    value: V;
  }

  interface ModalController {
    element: HTMLElement;
    /** Current values: form object, single field value, or true. */
    values(): any;
    /** Change the content (title, text, html, type, buttons, input, form, timer...). */
    update(next: ModalOptions): ModalController;
    /** Replace the whole content. */
    replace(next: ModalOptions): ModalController;
    loading(on?: boolean, text?: string): ModalController;
    /** Message under the form; "" hides it. */
    error(message: string): ModalController;
    fieldError(name: string, message: string): ModalController;
    close(result?: Partial<ModalResult>): void;
    stopTimer(): void;
    resumeTimer(): void;
    timeLeft(): number;
  }

  interface Step extends Omit<ModalOptions, "onConfirm"> {
    /** Key of this step in the result values. Default: "step1", "step2"... */
    name?: string;
    /** Text of the back button. */
    back?: string;
    /** Runs when going forward: return false to stay, or a value to store instead. */
    onConfirm?: ((value: any, modal: ModalController, values: Record<string, any>) => any) | null;
  }

  interface StepsResult {
    completed: boolean;
    /** Values of every step, keyed by step name. */
    values: Record<string, any>;
    /** Index of the last step shown. */
    step: number;
    action: ModalAction;
  }

  interface Modals {
    modal(options: ModalOptions | string): Promise<ModalResult>;
    alert(textOrOptions: string | ModalOptions, options?: ModalOptions): Promise<ModalResult>;
    /** Resolves true or false. */
    confirm(textOrOptions: string | ModalOptions, options?: ModalOptions): Promise<boolean>;
    /** Resolves the value, or null when cancelled. */
    prompt(textOrOptions: string | ModalOptions, value?: any, options?: ModalOptions): Promise<any>;
    /** Resolves the values object, or null when cancelled. */
    form<T = Record<string, any>>(fields: Field[] | HTMLElement | string, options?: ModalOptions): Promise<T | null>;
    steps(list: Step[], options?: ModalOptions): Promise<StepsResult>;
  }

  interface Mixin extends Modals {
    mixin(defaults: ModalOptions): Mixin;
  }

  interface JustAlerts extends Modals {
    readonly version: string;

    toast(options: ToastOptions | string): ToastHandle;
    show(options: ToastOptions | string): ToastHandle;
    success(message: string, options?: ToastOptions): ToastHandle;
    danger(message: string, options?: ToastOptions): ToastHandle;
    warning(message: string, options?: ToastOptions): ToastHandle;
    info(message: string, options?: ToastOptions): ToastHandle;
    /** Loading toast that turns into success or error. Returns the same promise. */
    promise<T>(
      promiseOrFn: Promise<T> | (() => T | Promise<T>),
      messages?: PromiseMessages<T>,
      options?: ToastOptions & { errorDuration?: number }
    ): Promise<T>;
    /** Close every toast, or only those in one position. */
    closeAll(position?: Position): void;
    /** Change the default toast options (theme and lang also apply to modals); returns the defaults. */
    config(options: ToastOptions): Required<ToastOptions>;

    /** Modal functions with their own defaults. */
    mixin(defaults: ModalOptions): Mixin;
    /** Topmost open modal, or null. */
    current(): ModalController | null;
    isOpen(): boolean;
    closeModal(result?: Partial<ModalResult>): void;
    /** Form (or any container) to an object: checkbox groups as arrays, numbers as Number, files as File. */
    serialize(form: Element): Record<string, any>;

    /** v1 API: alerta(tipo, mensaje, x, y, tiempo, distancia). The message accepts HTML. */
    legacy(
      tipo: AlertType,
      mensaje: string,
      x?: "left" | "right",
      y?: "top" | "bottom",
      tiempo?: number,
      distancia?: number
    ): ToastHandle;
  }
}

declare const justAlerts: justAlerts.JustAlerts;
export = justAlerts;
export as namespace justAlerts;