valtech-components 2.0.510 → 2.0.511

package/lib/components/molecules/refresher/refresher.component.d.ts

@@ -0,0 +1,79 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { IonRefresher } from '@ionic/angular/standalone';
+import { RefresherMetadata, RefresherState, RefreshEvent, RefreshPullEvent } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Componente de pull-to-refresh para movil y web.
+ *
+ * @example
+ * <!-- Uso basico -->
+ * <val-refresher
+ *   [props]="{
+ *     color: 'primary',
+ *     pullingText: 'Arrastra para actualizar',
+ *     refreshingText: 'Cargando...'
+ *   }"
+ *   (refresh)="onRefresh($event)"
+ * >
+ *   <ion-content>
+ *     <!-- Contenido scrolleable -->
+ *   </ion-content>
+ * </val-refresher>
+ *
+ * @example
+ * <!-- Con indicador personalizado -->
+ * <val-refresher [props]="{ color: 'primary' }" (refresh)="onRefresh($event)">
+ *   <ng-template #pullingIndicator let-progress="progress">
+ *     <div class="custom-indicator">
+ *       <ion-icon name="arrow-down" [style.transform]="'rotate(' + progress * 180 + 'deg)'"></ion-icon>
+ *     </div>
+ *   </ng-template>
+ *   <ion-content>...</ion-content>
+ * </val-refresher>
+ */
+export declare class RefresherComponent {
+    ionRefresher: IonRefresher;
+    /** Templates personalizados via content projection */
+    pullingIndicator?: TemplateRef<{
+        progress: number;
+    }>;
+    refreshingIndicator?: TemplateRef<void>;
+    completingIndicator?: TemplateRef<void>;
+    /** Configuracion del refresher */
+    props: RefresherMetadata;
+    /** Evento emitido cuando se activa el refresh */
+    refresh: EventEmitter<RefreshEvent>;
+    /** Evento de progreso durante el pull */
+    pullProgressChange: EventEmitter<RefreshPullEvent>;
+    /** Evento de cambio de estado */
+    stateChange: EventEmitter<RefresherState>;
+    /** Estado actual del refresher */
+    readonly state: import("@angular/core").WritableSignal<RefresherState>;
+    /** Progreso actual del pull (0-1) */
+    readonly pullProgress: import("@angular/core").WritableSignal<number>;
+    /** Props combinados con defaults */
+    get mergedProps(): RefresherMetadata;
+    /** Si hay indicadores personalizados */
+    get hasCustomIndicator(): boolean;
+    /**
+     * Activa programaticamente el refresh.
+     */
+    triggerRefresh(): void;
+    /**
+     * Completa la operacion de refresh actual.
+     */
+    complete(): void;
+    /**
+     * Cancela la operacion de refresh actual.
+     */
+    cancel(): void;
+    /** Handler para evento ionRefresh */
+    onIonRefresh(event: CustomEvent): void;
+    /** Handler para evento ionPull */
+    onIonPull(event: CustomEvent): void;
+    /** Handler para evento ionStart */
+    onIonStart(): void;
+    private emitRefreshEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RefresherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RefresherComponent, "val-refresher", never, { "props": { "alias": "props"; "required": false; }; }, { "refresh": "refresh"; "pullProgressChange": "pullProgressChange"; "stateChange": "stateChange"; }, ["pullingIndicator", "refreshingIndicator", "completingIndicator"], ["*"], true, never>;
+}

package/lib/components/molecules/refresher/types.d.ts

@@ -0,0 +1,86 @@
+import { TemplateRef } from '@angular/core';
+import { Color } from '@ionic/core';
+/**
+ * Estado del componente refresher.
+ */
+export type RefresherState = 'idle' | 'pulling' | 'refreshing' | 'completing';
+/**
+ * Tipos de spinner disponibles.
+ */
+export type RefresherSpinnerType = 'circular' | 'crescent' | 'dots' | 'lines-sharp';
+/**
+ * Evento emitido cuando se activa el refresh.
+ */
+export interface RefreshEvent {
+    /** Llamar cuando la operacion de refresh completa */
+    complete: () => void;
+    /** Llamar para cancelar el refresh */
+    cancel: () => void;
+    /** Timestamp cuando inicio el refresh */
+    timestamp: Date;
+}
+/**
+ * Evento de progreso durante el gesto de pull.
+ */
+export interface RefreshPullEvent {
+    /** Valor de progreso entre 0 y 1 */
+    progress: number;
+    /** Si se ha alcanzado el umbral de pull */
+    thresholdReached: boolean;
+}
+/**
+ * Configuracion de indicador personalizado.
+ */
+export interface RefresherIndicatorConfig {
+    /** Template personalizado para estado pulling */
+    pullingTemplate?: TemplateRef<{
+        progress: number;
+    }>;
+    /** Template personalizado para estado refreshing */
+    refreshingTemplate?: TemplateRef<void>;
+    /** Template personalizado para estado completing */
+    completingTemplate?: TemplateRef<void>;
+}
+/**
+ * Metadata para el componente val-refresher.
+ */
+export interface RefresherMetadata {
+    /** Si el refresher esta deshabilitado */
+    disabled?: boolean;
+    /** Umbral de pull en pixels (default: 70) */
+    pullThreshold?: number;
+    /** Distancia maxima de pull en pixels (default: 200) */
+    pullMax?: number;
+    /** Factor de resistencia del pull (0-1, default: 0.5) */
+    pullFactor?: number;
+    /** Duracion de snap back en ms (default: 280) */
+    snapbackDuration?: number;
+    /** Duracion de cierre en ms (default: 280) */
+    closeDuration?: number;
+    /** Color del spinner */
+    color?: Color;
+    /** Tipo de spinner */
+    spinnerType?: RefresherSpinnerType;
+    /** Texto mostrado mientras se arrastra */
+    pullingText?: string;
+    /** Texto mostrado mientras se actualiza */
+    refreshingText?: string;
+    /** Configuracion de indicador personalizado */
+    indicatorConfig?: RefresherIndicatorConfig;
+    /** Habilitar feedback haptico en movil (default: true) */
+    hapticFeedback?: boolean;
+    /** Modo web - habilita pull-to-refresh en navegadores desktop */
+    webMode?: boolean;
+    /** Identificador unico */
+    token?: string;
+    /** Key de traduccion para texto pulling */
+    pullingTextKey?: string;
+    /** Key de traduccion para texto refreshing */
+    refreshingTextKey?: string;
+    /** Clase CSS adicional */
+    contentClass?: string;
+}
+/**
+ * Valores por defecto para el refresher.
+ */
+export declare const DEFAULT_REFRESHER_METADATA: Partial<RefresherMetadata>;

package/lib/components/organisms/infinite-list/infinite-list.component.d.ts

@@ -0,0 +1,111 @@
+import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { IonInfiniteScroll } from '@ionic/angular/standalone';
+import { InfiniteListMetadata, InfiniteListState, LoadMoreEvent } from './types';
+import { RefreshEvent, RefresherMetadata } from '../../molecules/refresher/types';
+import * as i0 from "@angular/core";
+/**
+ * Componente wrapper para listas con infinite scroll.
+ *
+ * @example
+ * <!-- Uso basico con data source -->
+ * <val-infinite-list
+ *   [props]="{
+ *     dataSource: { loadFn: loadUsers, trackBy: trackByUserId },
+ *     itemTemplate: userTemplate,
+ *     pageSize: 20,
+ *     threshold: '150px'
+ *   }"
+ * ></val-infinite-list>
+ *
+ * <ng-template #userTemplate let-user let-index="index">
+ *   <val-card [props]="{ title: user.name, subtitle: user.email }">
+ *     <p>{{ user.bio }}</p>
+ *   </val-card>
+ * </ng-template>
+ *
+ * @example
+ * <!-- Con pull-to-refresh y estado vacio personalizado -->
+ * <val-infinite-list
+ *   [props]="{
+ *     dataSource: { loadFn: loadMessages },
+ *     itemTemplate: messageTemplate,
+ *     direction: 'both',
+ *     enableRefresh: true,
+ *     emptyState: {
+ *       icon: 'chatbubbles-outline',
+ *       title: 'Sin mensajes',
+ *       message: 'Inicia una conversacion'
+ *     },
+ *     skeleton: { template: 'list', count: 5 }
+ *   }"
+ *   (refresh)="onRefresh($event)"
+ * ></val-infinite-list>
+ */
+export declare class InfiniteListComponent<T = unknown> implements OnInit, OnDestroy {
+    private readonly skeletonService;
+    private readonly cdr;
+    infiniteScroll?: IonInfiniteScroll;
+    /** Configuracion del componente */
+    props: InfiniteListMetadata<T>;
+    loadMore: EventEmitter<LoadMoreEvent>;
+    refresh: EventEmitter<RefreshEvent>;
+    stateChange: EventEmitter<InfiniteListState>;
+    itemsChange: EventEmitter<T[]>;
+    errorOccurred: EventEmitter<Error>;
+    readonly items: import("@angular/core").WritableSignal<T[]>;
+    readonly state: import("@angular/core").WritableSignal<InfiniteListState>;
+    readonly hasMoreBottom: import("@angular/core").WritableSignal<boolean>;
+    readonly hasMoreTop: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<Error>;
+    readonly isInitialLoad: import("@angular/core").WritableSignal<boolean>;
+    private currentPage;
+    private currentCursor;
+    /** Progreso de carga (0-1 si totalCount conocido) */
+    readonly loadProgress: import("@angular/core").Signal<number>;
+    /** Props combinados con defaults */
+    get mergedProps(): InfiniteListMetadata<T>;
+    /** Config del refresher */
+    get refresherConfig(): RefresherMetadata;
+    /** Componente de skeleton a usar */
+    get skeletonComponent(): import("@angular/core").Type<unknown>;
+    /** Inputs para el skeleton */
+    get skeletonInputs(): {
+        config: unknown;
+    };
+    /** Anuncio de estado para lectores de pantalla */
+    readonly statusAnnouncement: import("@angular/core").Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Funcion de tracking para ngFor */
+    trackByFn(index: number, item: T): unknown;
+    /** Si debe mostrar el scroll inferior */
+    shouldShowBottomScroll(): boolean;
+    /** Carga inicial de datos */
+    loadInitial(): Promise<void>;
+    /** Cargar mas items en la parte inferior */
+    loadBottom(): Promise<void>;
+    /** Cargar mas items en la parte superior */
+    loadTop(): Promise<void>;
+    /** Refresh - recargar desde cero */
+    refreshList(): Promise<void>;
+    /** Reintentar despues de error */
+    retry(): Promise<void>;
+    /** Reset completo */
+    reset(): Promise<void>;
+    /** Agregar items al inicio */
+    prependItems(newItems: T[]): void;
+    /** Agregar items al final */
+    appendItems(newItems: T[]): void;
+    /** Actualizar un item por indice */
+    updateItem(index: number, item: T): void;
+    /** Remover un item por indice */
+    removeItem(index: number): void;
+    /** Handler para evento de infinite scroll */
+    onInfiniteScroll(event: CustomEvent): Promise<void>;
+    /** Handler para evento de refresh */
+    onRefreshTriggered(event: RefreshEvent): Promise<void>;
+    private executeLoad;
+    private handleError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InfiniteListComponent<any>, "val-infinite-list", never, { "props": { "alias": "props"; "required": false; }; }, { "loadMore": "loadMore"; "refresh": "refresh"; "stateChange": "stateChange"; "itemsChange": "itemsChange"; "errorOccurred": "errorOccurred"; }, never, never, true, never>;
+}

package/lib/components/organisms/infinite-list/types.d.ts

@@ -0,0 +1,197 @@
+import { TemplateRef } from '@angular/core';
+import { Color } from '@ionic/core';
+import { Observable } from 'rxjs';
+import { SkeletonTemplateName, SkeletonTemplateConfig } from '../../../services/skeleton/types';
+import { RefresherMetadata } from '../../molecules/refresher/types';
+/**
+ * Direccion de carga de mas items.
+ */
+export type LoadDirection = 'bottom' | 'top' | 'both';
+/**
+ * Estado de la lista infinita.
+ */
+export type InfiniteListState = 'idle' | 'loading' | 'error' | 'complete';
+/**
+ * Parametros pasados a la funcion de carga.
+ */
+export interface LoadParams {
+    /** Direccion de carga */
+    direction: 'bottom' | 'top';
+    /** Pagina actual (para paginacion basada en offset) */
+    page: number;
+    /** Items por pagina */
+    pageSize: number;
+    /** Ultimo item (para paginacion basada en cursor) */
+    lastItem?: unknown;
+    /** Primer item (para carga top con cursor) */
+    firstItem?: unknown;
+    /** Cursor personalizado (del LoadResult anterior) */
+    cursor?: unknown;
+}
+/**
+ * Resultado de la funcion de carga.
+ */
+export interface LoadResult<T> {
+    /** Items cargados */
+    items: T[];
+    /** Si hay mas items disponibles */
+    hasMore: boolean;
+    /** Cursor personalizado para proxima carga (opcional) */
+    cursor?: unknown;
+    /** Actualizacion de conteo total (opcional) */
+    totalCount?: number;
+}
+/**
+ * Configuracion del data source.
+ */
+export interface InfiniteListDataSource<T> {
+    /** Items iniciales (opcional si usa loadFn) */
+    items?: T[];
+    /** Funcion para cargar mas items */
+    loadFn?: (params: LoadParams) => Observable<LoadResult<T>> | Promise<LoadResult<T>>;
+    /** Funcion track para ngFor (default: index) */
+    trackBy?: (index: number, item: T) => unknown;
+    /** Conteo total si se conoce (habilita indicador de progreso) */
+    totalCount?: number;
+}
+/**
+ * Evento emitido al cargar mas items.
+ */
+export interface LoadMoreEvent {
+    /** Parametros de carga */
+    params: LoadParams;
+    /** Llamar cuando la carga completa */
+    complete: (result: LoadResult<unknown>) => void;
+    /** Llamar cuando la carga falla */
+    error: (error: Error) => void;
+}
+/**
+ * Configuracion de estado vacio.
+ */
+export interface InfiniteListEmptyState {
+    /** Nombre del icono */
+    icon?: string;
+    /** Texto del titulo */
+    title?: string;
+    /** Texto del mensaje */
+    message?: string;
+    /** Template personalizado */
+    template?: TemplateRef<void>;
+    titleKey?: string;
+    messageKey?: string;
+    contentClass?: string;
+}
+/**
+ * Configuracion de estado de error.
+ */
+export interface InfiniteListErrorState {
+    /** Icono de error */
+    icon?: string;
+    /** Titulo del error */
+    title?: string;
+    /** Mensaje del error */
+    message?: string;
+    /** Mostrar boton de reintentar */
+    showRetry?: boolean;
+    /** Texto del boton de reintentar */
+    retryText?: string;
+    /** Template personalizado */
+    template?: TemplateRef<{
+        error: Error;
+        retry: () => void;
+    }>;
+    titleKey?: string;
+    messageKey?: string;
+    retryTextKey?: string;
+    contentClass?: string;
+}
+/**
+ * Configuracion de skeleton para carga.
+ */
+export interface InfiniteListSkeletonConfig {
+    /** Template de skeleton a usar */
+    template?: SkeletonTemplateName | string;
+    /** Numero de items skeleton a mostrar */
+    count?: number;
+    /** Template personalizado */
+    customTemplate?: TemplateRef<void>;
+    /** Configuracion adicional */
+    config?: SkeletonTemplateConfig;
+}
+/**
+ * Contexto para el template de items.
+ */
+export interface InfiniteListItemContext<T> {
+    /** El item actual */
+    $implicit: T;
+    /** Indice del item */
+    index: number;
+    /** Si es el primer item */
+    first: boolean;
+    /** Si es el ultimo item */
+    last: boolean;
+    /** Items totales */
+    count: number;
+}
+/**
+ * Metadata para el componente val-infinite-list.
+ */
+export interface InfiniteListMetadata<T = unknown> {
+    /** Configuracion del data source */
+    dataSource: InfiniteListDataSource<T>;
+    /** Direccion de carga */
+    direction?: LoadDirection;
+    /** Items por pagina (default: 20) */
+    pageSize?: number;
+    /** Distancia del borde para activar carga (default: '100px') */
+    threshold?: string;
+    /** Tiempo de debounce para eventos de carga en ms (default: 300) */
+    debounceTime?: number;
+    /** Cargar primera pagina automaticamente al inicializar (default: true) */
+    autoLoad?: boolean;
+    /** Template para renderizar cada item (requerido) */
+    itemTemplate: TemplateRef<InfiniteListItemContext<T>>;
+    /** Template para el indicador de carga en bottom */
+    loadingTemplate?: TemplateRef<void>;
+    /** Template para el indicador de carga en top */
+    topLoadingTemplate?: TemplateRef<void>;
+    /** Configuracion de estado vacio */
+    emptyState?: InfiniteListEmptyState;
+    /** Configuracion de estado de error */
+    errorState?: InfiniteListErrorState;
+    /** Configuracion de skeleton para carga inicial */
+    skeleton?: InfiniteListSkeletonConfig;
+    /** Tipo de spinner */
+    spinnerType?: 'circular' | 'crescent' | 'dots' | 'lines-sharp';
+    /** Color del spinner */
+    color?: Color;
+    /** Usar boton "Cargar mas" en lugar de auto-carga */
+    useLoadMoreButton?: boolean;
+    /** Texto del boton "Cargar mas" */
+    loadMoreText?: string;
+    /** Texto cuando no hay mas items */
+    noMoreText?: string;
+    /** Habilitar pull-to-refresh */
+    enableRefresh?: boolean;
+    /** Configuracion del refresher */
+    refreshConfig?: RefresherMetadata;
+    /** Clase CSS para el contenedor */
+    cssClass?: string;
+    /** Altura maxima (habilita scroll interno) */
+    maxHeight?: string;
+    /** Mostrar divisores entre items */
+    showDividers?: boolean;
+    /** ARIA label para la lista */
+    ariaLabel?: string;
+    /** ARIA description */
+    ariaDescription?: string;
+    /** Identificador unico */
+    token?: string;
+    loadMoreTextKey?: string;
+    noMoreTextKey?: string;
+    contentClass?: string;
+}
+/**
+ * Valores por defecto para infinite list.
+ */
+export declare const DEFAULT_INFINITE_LIST_METADATA: Partial<InfiniteListMetadata>;

package/lib/services/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { PaginationStrategy, PaginationState, PaginationLoadParams, PaginationLoadResult, PaginationConfig, PaginationController, createInitialPaginationState, } from './types';
+export { PaginationService } from './pagination.service';

package/lib/services/pagination/pagination.service.d.ts

@@ -0,0 +1,43 @@
+import { PaginationConfig, PaginationController } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para crear controladores de paginacion reutilizables.
+ *
+ * @example
+ * // En un componente
+ * pagination = inject(PaginationService);
+ *
+ * usersController = this.pagination.createController<User>({
+ *   strategy: 'offset',
+ *   pageSize: 20,
+ *   loadFn: (params) => this.userService.getUsers(params.page, params.pageSize)
+ * });
+ *
+ * // En el template
+ * @for (user of usersController.items(); track user.id) {
+ *   <app-user-card [user]="user"></app-user-card>
+ * }
+ *
+ * @if (usersController.hasMore()) {
+ *   <ion-button (click)="usersController.loadNext()">Cargar mas</ion-button>
+ * }
+ */
+export declare class PaginationService {
+    /**
+     * Crea un controlador de paginacion para una fuente de datos.
+     *
+     * @param config Configuracion del controlador
+     * @returns Controlador de paginacion
+     */
+    createController<T>(config: PaginationConfig<T>): PaginationController<T>;
+    /**
+     * Crea un controlador simple para arrays estaticos con paginacion local.
+     *
+     * @param items Array completo de items
+     * @param pageSize Tamano de pagina
+     * @returns Controlador de paginacion
+     */
+    createLocalController<T>(items: T[], pageSize?: number): PaginationController<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationService>;
+}

package/lib/services/pagination/types.d.ts

@@ -0,0 +1,113 @@
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+/**
+ * Estrategia de paginacion.
+ */
+export type PaginationStrategy = 'offset' | 'cursor' | 'page';
+/**
+ * Estado de paginacion.
+ */
+export interface PaginationState<T> {
+    /** Items actuales */
+    items: T[];
+    /** Pagina actual (para estrategia offset/page) */
+    page: number;
+    /** Tamano de pagina */
+    pageSize: number;
+    /** Conteo total (si se conoce) */
+    total?: number;
+    /** Cursor para siguiente pagina (para estrategia cursor) */
+    nextCursor?: unknown;
+    /** Cursor para pagina anterior */
+    prevCursor?: unknown;
+    /** Si existen mas items */
+    hasMore: boolean;
+    /** Estado de carga */
+    isLoading: boolean;
+    /** Estado de error */
+    error?: Error;
+}
+/**
+ * Parametros para funcion de carga.
+ */
+export interface PaginationLoadParams {
+    /** Estrategia de paginacion */
+    strategy: PaginationStrategy;
+    /** Numero de pagina */
+    page: number;
+    /** Tamano de pagina */
+    pageSize: number;
+    /** Cursor (para estrategia cursor) */
+    cursor?: unknown;
+    /** Direccion de carga */
+    direction: 'forward' | 'backward';
+}
+/**
+ * Resultado de funcion de carga.
+ */
+export interface PaginationLoadResult<T> {
+    /** Items cargados */
+    items: T[];
+    /** Si hay mas items */
+    hasMore: boolean;
+    /** Total de items (opcional) */
+    total?: number;
+    /** Cursor para siguiente pagina */
+    nextCursor?: unknown;
+    /** Cursor para pagina anterior */
+    prevCursor?: unknown;
+}
+/**
+ * Configuracion para crear un controlador de paginacion.
+ */
+export interface PaginationConfig<T> {
+    /** Estrategia de paginacion */
+    strategy: PaginationStrategy;
+    /** Tamano de pagina */
+    pageSize?: number;
+    /** Items iniciales (opcional) */
+    initialItems?: T[];
+    /** Funcion de carga */
+    loadFn: (params: PaginationLoadParams) => Observable<PaginationLoadResult<T>> | Promise<PaginationLoadResult<T>>;
+    /** Funcion de tracking para items */
+    trackBy?: (item: T) => unknown;
+}
+/**
+ * Interface del controlador de paginacion.
+ */
+export interface PaginationController<T> {
+    /** Estado reactivo como signal */
+    state: Signal<PaginationState<T>>;
+    /** Signal de items (accessor de conveniencia) */
+    items: Signal<T[]>;
+    /** Signal de carga */
+    isLoading: Signal<boolean>;
+    /** Signal de mas items */
+    hasMore: Signal<boolean>;
+    /** Signal de error */
+    error: Signal<Error | null>;
+    /** Signal de pagina actual */
+    currentPage: Signal<number>;
+    /** Signal de total */
+    total: Signal<number | undefined>;
+    /** Cargar siguiente pagina */
+    loadNext(): Promise<void>;
+    /** Cargar pagina anterior (si soportado) */
+    loadPrevious(): Promise<void>;
+    /** Refresh (recargar desde inicio) */
+    refresh(): Promise<void>;
+    /** Reset a estado inicial */
+    reset(): void;
+    /** Actualizar un item */
+    updateItem(predicate: (item: T) => boolean, updates: Partial<T>): void;
+    /** Remover un item */
+    removeItem(predicate: (item: T) => boolean): void;
+    /** Agregar items al inicio */
+    prependItems(items: T[]): void;
+    /** Agregar items al final */
+    appendItems(items: T[]): void;
+}
+/**
+ * Estado inicial para controladores de paginacion.
+ */
+export declare function createInitialPaginationState<T>(pageSize: number, initialItems?: T[]): PaginationState<T>;

package/lib/services/skeleton/config.d.ts

@@ -0,0 +1,30 @@
+import { EnvironmentProviders } from '@angular/core';
+import { SkeletonConfig } from './types';
+/**
+ * Configura el sistema de skeletons para Valtech Components.
+ *
+ * @param config Configuracion de skeletons
+ * @returns Providers para app.config.ts
+ *
+ * @example
+ * // app.config.ts
+ * import { provideValtechSkeleton } from 'valtech-components';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideValtechSkeleton({
+ *       animated: true,
+ *       defaultDelay: 100,
+ *       defaultMinTime: 500,
+ *       templates: [
+ *         { name: 'custom-card', component: MyCustomCardSkeleton }
+ *       ]
+ *     }),
+ *   ]
+ * };
+ *
+ * @example
+ * // Uso minimo - usa configuracion por defecto
+ * providers: [provideValtechSkeleton()]
+ */
+export declare function provideValtechSkeleton(config?: SkeletonConfig): EnvironmentProviders;