valtech-components 2.0.503 → 2.0.505

package/lib/components/molecules/ad-slot/ad-slot.component.d.ts

@@ -1,7 +1,7 @@
 /**
  * Ad Slot Component
  *
- * Componente standalone para mostrar ads de Google Ad Manager.
+ * Componente standalone para mostrar ads de Google AdSense.
  * Se integra automaticamente con el servicio de Ads y respeta consent + premium.
  *
  * @example
@@ -9,52 +9,41 @@
  * <!-- Banner basico -->
  * <val-ad-slot
  *   slotId="homepage-top"
- *   adUnitPath="/homepage/top"
- *   size="leaderboard"
+ *   format="horizontal"
+ *   [fullWidth]="true"
  * />
  *
- * <!-- Con responsivo -->
+ * <!-- Rectangle ad -->
  * <val-ad-slot
  *   slotId="sidebar-ad"
- *   adUnitPath="/sidebar"
- *   [size]="['medium-rectangle', 'half-page']"
- *   [sizeMapping]="[
- *     { viewportWidth: 1024, sizes: [[300, 600]] },
- *     { viewportWidth: 768, sizes: [[300, 250]] },
- *     { viewportWidth: 0, sizes: [[320, 50]] }
- *   ]"
+ *   adSlot="1234567890"
+ *   format="rectangle"
  * />
  *
- * <!-- Native ad -->
+ * <!-- Auto format (Google decides) -->
  * <val-ad-slot
- *   slotId="article-native"
- *   adUnitPath="/article/native"
- *   size="native"
- *   [isNative]="true"
+ *   slotId="article-ad"
+ *   format="auto"
+ *   [fullWidth]="true"
  * />
  * ```
  */
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit } from '@angular/core';
 import { AdsService } from '../../../services/ads/ads.service';
-import { AdSlotSize, AdSlotState, SizeMapping } from '../../../services/ads/types';
+import { AdFormat, AdSlotState } from '../../../services/ads/types';
 import * as i0 from "@angular/core";
-export declare class AdSlotComponent implements OnInit, OnDestroy {
+export declare class AdSlotComponent implements OnInit, OnDestroy, AfterViewInit {
     readonly adsService: AdsService;
     private readonly platformId;
-    /** ID unico del slot */
+    private readonly elementRef;
+    /** ID unico del slot (para tracking interno) */
     slotId: string;
-    /** Ad unit path (sin el network ID) */
-    adUnitPath: string;
-    /** Tamano del ad */
-    size: AdSlotSize | AdSlotSize[] | [number, number] | [number, number][];
-    /** Mapping responsivo */
-    sizeMapping?: SizeMapping[];
-    /** Targeting especifico */
-    targeting?: Record<string, string | string[]>;
-    /** Colapsar si vacio */
-    collapseEmpty: boolean;
-    /** Es native ad */
-    isNative: boolean;
+    /** Ad Slot ID de AdSense (opcional, para unidades manuales) */
+    adSlot?: string;
+    /** Formato del ad */
+    format: AdFormat;
+    /** Full width responsive */
+    fullWidth: boolean;
     /** CSS class adicional */
     cssClass: string;
     /** Altura minima */
@@ -63,16 +52,13 @@ export declare class AdSlotComponent implements OnInit, OnDestroy {
     showSkeleton: boolean;
     private readonly _state;
     readonly state: import("@angular/core").Signal<AdSlotState>;
+    private adInitialized;
     /** Indica si el componente debe renderizarse */
     readonly shouldRender: import("@angular/core").Signal<boolean>;
-    /** Ancho del skeleton */
-    readonly skeletonWidth: import("@angular/core").Signal<string>;
-    /** Altura del skeleton */
-    readonly skeletonHeight: import("@angular/core").Signal<string>;
     ngOnInit(): Promise<void>;
+    ngAfterViewInit(): Promise<void>;
     ngOnDestroy(): void;
-    private initializeSlot;
-    private getFirstSize;
+    private initializeAd;
     static ɵfac: i0.ɵɵFactoryDeclaration<AdSlotComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AdSlotComponent, "val-ad-slot", never, { "slotId": { "alias": "slotId"; "required": true; }; "adUnitPath": { "alias": "adUnitPath"; "required": true; }; "size": { "alias": "size"; "required": false; }; "sizeMapping": { "alias": "sizeMapping"; "required": false; }; "targeting": { "alias": "targeting"; "required": false; }; "collapseEmpty": { "alias": "collapseEmpty"; "required": false; }; "isNative": { "alias": "isNative"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "showSkeleton": { "alias": "showSkeleton"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdSlotComponent, "val-ad-slot", never, { "slotId": { "alias": "slotId"; "required": true; }; "adSlot": { "alias": "adSlot"; "required": false; }; "format": { "alias": "format"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "showSkeleton": { "alias": "showSkeleton"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/components/organisms/article/article.component.d.ts

@@ -45,7 +45,7 @@ export declare class ArticleComponent implements OnInit {
     getVideoElement(element: ArticleElement): ArticleVideoElement;
     getCustomElement(element: ArticleElement): ArticleCustomElement;
     getQuoteTextProps(element: ArticleElement): {
-        size: "medium" | "small" | "large" | "xlarge";
+        size: "small" | "medium" | "large" | "xlarge";
         color: import("@ionic/core").Color;
         content?: string;
         bold: boolean;
@@ -61,7 +61,7 @@ export declare class ArticleComponent implements OnInit {
         showQuoteMark?: boolean;
     };
     getHighlightTextProps(element: ArticleElement): {
-        size: "medium" | "small" | "large" | "xlarge";
+        size: "small" | "medium" | "large" | "xlarge";
         color: import("@ionic/core").Color;
         content?: string;
         bold: boolean;
@@ -90,7 +90,7 @@ export declare class ArticleComponent implements OnInit {
         contentInterpolation?: Record<string, string | number>;
         icon?: import("valtech-components").IconMetada;
         shape?: "round";
-        size?: "default" | "small" | "large";
+        size?: "small" | "large" | "default";
         fill?: "default" | "clear" | "outline" | "solid";
         type: "button" | "submit" | "reset";
         token?: string;

package/lib/services/ads/ads-loader.service.d.ts

@@ -1,8 +1,7 @@
-import { ValtechAdsConfig, GPTNamespace } from './types';
-import { AdsConsentService } from './ads-consent.service';
+import { ValtechAdsConfig } from './types';
 import * as i0 from "@angular/core";
 /**
- * Servicio para cargar el script de Google Publisher Tags.
+ * Servicio para cargar el script de Google AdSense.
  *
  * Implementa lazy loading: el script solo se carga cuando
  * se solicita renderizar el primer ad slot.
@@ -10,7 +9,6 @@ import * as i0 from "@angular/core";
 export declare class AdsLoaderService {
     private config;
     private platformId;
-    private consentService;
     private readonly _isLoading;
     private readonly _isLoaded;
     private readonly _error;
@@ -21,26 +19,23 @@ export declare class AdsLoaderService {
     /** Error de carga (si existe) */
     readonly error: import("@angular/core").Signal<Error>;
     private loadPromise;
-    constructor(config: ValtechAdsConfig, platformId: Object, consentService: AdsConsentService);
+    constructor(config: ValtechAdsConfig, platformId: Object);
     /**
-     * Carga el script GPT de forma lazy.
-     * Retorna la instancia de googletag o null si falla.
+     * Carga el script AdSense de forma lazy.
+     * Retorna true si se cargo correctamente, false si fallo.
      *
-     * @returns Promise con googletag o null
+     * @returns Promise<boolean>
      */
-    loadGPT(): Promise<GPTNamespace | null>;
+    loadAdSense(): Promise<boolean>;
     /**
-     * Configura GPT con las opciones de la aplicacion.
+     * Verifica si el script AdSense esta disponible.
      */
-    private configureGPT;
+    isAdSenseAvailable(): boolean;
     /**
-     * Verifica si el script GPT esta disponible.
+     * Ejecuta un comando AdSense (push a la queue).
+     * Usado internamente para activar ad slots.
      */
-    isGPTAvailable(): boolean;
-    /**
-     * Obtiene la instancia de googletag si esta cargada.
-     */
-    getGPT(): GPTNamespace | null;
+    pushAdCommand(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AdsLoaderService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AdsLoaderService>;
 }

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

@@ -1,20 +1,20 @@
 /**
  * Ads Service
  *
- * Servicio principal para Google Ad Manager (GPT).
- * Integra con el sistema de consent existente y respeta usuarios premium.
+ * Servicio principal para Google AdSense.
+ * Integra con el sistema de auth para detectar usuarios premium.
  */
-import { Injector, OnDestroy } from '@angular/core';
+import { OnDestroy } from '@angular/core';
 import { Router } from '@angular/router';
 import { AdsLoaderService } from './ads-loader.service';
-import { AdsConsentService } from './ads-consent.service';
-import { ValtechAdsConfig, AdSlotConfig, AdSlotState, AdEvent, GPTNamespace } from './types';
+import { AuthStateService } from '../auth/auth-state.service';
+import { ValtechAdsConfig, AdSlotState, AdEvent } from './types';
 import * as i0 from "@angular/core";
 /**
- * Servicio principal de Google Ad Manager.
+ * Servicio principal de Google AdSense.
  *
- * Maneja la creacion, destruccion y refresh de ad slots.
- * Integra automaticamente con consent mode y detecta usuarios premium.
+ * Maneja la carga del script y el estado de ads.
+ * Detecta automaticamente usuarios premium para ocultar ads.
  *
  * @example
  * ```typescript
@@ -31,66 +31,57 @@ import * as i0 from "@angular/core";
  * ```
  */
 export declare class AdsService implements OnDestroy {
-    private injector;
     private config;
     private platformId;
     private router;
     private loaderService;
-    private consentService;
-    private readonly authStateService;
+    private authStateService;
     private readonly _isInitialized;
     private readonly _isEnabled;
     private readonly _isDebugMode;
-    private readonly _slots;
     private readonly _slotStates;
     private readonly _events;
+    private readonly _adClient;
     /** Indica si el servicio esta inicializado */
     readonly isInitialized: import("@angular/core").Signal<boolean>;
-    /** Indica si los ads estan habilitados (consent + no premium) */
+    /** Indica si los ads estan habilitados (no premium + inicializado) */
     readonly isEnabled: import("@angular/core").Signal<boolean>;
-    /** Indica si el usuario es premium (no ve ads) - lee de AuthStateService */
+    /** Indica si el usuario es premium (no ve ads) */
     readonly isPremiumUser: import("@angular/core").Signal<boolean>;
     /** Indica si esta en modo debug */
     readonly isDebugMode: import("@angular/core").Signal<boolean>;
-    /** Estado de consent para ads */
-    readonly consentState: import("@angular/core").Signal<import("./types").AdsConsentState>;
+    /** Publisher ID de AdSense */
+    readonly adClient: import("@angular/core").Signal<string>;
     /** Eventos de ads (historial) */
     readonly events: import("@angular/core").Signal<AdEvent[]>;
-    private activeSlots;
+    private activeSlotIds;
     private routerSubscription;
-    private refreshTimerId;
-    constructor(injector: Injector, config: ValtechAdsConfig, platformId: Object, router: Router, loaderService: AdsLoaderService, consentService: AdsConsentService);
+    constructor(config: ValtechAdsConfig, platformId: Object, router: Router, loaderService: AdsLoaderService, authStateService: AuthStateService);
     /**
      * Inicializa el servicio de ads.
      * Llamado automaticamente por APP_INITIALIZER.
-     * NO carga el script GPT hasta que se necesite el primer ad.
+     * NO carga el script AdSense hasta que se necesite el primer ad.
      */
     initialize(): Promise<void>;
     /**
-     * Carga el script GPT de forma lazy.
+     * Carga el script AdSense de forma lazy.
      * Llamado automaticamente cuando se renderiza el primer ad slot.
      */
-    ensureGPTLoaded(): Promise<GPTNamespace | null>;
+    ensureAdSenseLoaded(): Promise<boolean>;
     /**
-     * Define y muestra un ad slot.
+     * Registra un ad slot.
      * Llamado internamente por el componente AdSlot.
      *
-     * @param config - Configuracion del slot
-     * @returns ID del slot o null si no se puede mostrar
+     * @param slotId - ID unico del slot
+     * @returns true si el slot se puede mostrar
      */
-    defineSlot(config: AdSlotConfig): Promise<string | null>;
+    registerSlot(slotId: string): Promise<boolean>;
     /**
-     * Destruye un slot y libera recursos.
+     * Desregistra un slot.
      *
-     * @param slotId - ID del slot a destruir
+     * @param slotId - ID del slot a desregistrar
      */
-    destroySlot(slotId: string): void;
-    /**
-     * Refresca un slot especifico o todos los slots activos.
-     *
-     * @param slotIds - IDs de slots a refrescar (undefined = todos)
-     */
-    refreshSlots(slotIds?: string[]): void;
+    unregisterSlot(slotId: string): void;
     /**
      * Obtiene el estado de un slot.
      *
@@ -98,18 +89,9 @@ export declare class AdsService implements OnDestroy {
      * @returns Estado actual del slot
      */
     getSlotState(slotId: string): AdSlotState;
-    /**
-     * Destruye todos los slots activos.
-     * Llamar cuando el usuario se vuelve premium o cambia de página.
-     */
-    destroyAllSlots(): void;
-    private resolveSizes;
-    private buildSizeMapping;
-    private applyTargeting;
     private updateSlotState;
     private emitEvent;
     private setupRouteListener;
-    private setupAutoRefresh;
     private isRouteExcluded;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AdsService, never>;

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

@@ -1,20 +1,16 @@
 /**
  * Ads Configuration
  *
- * Configuracion e inicializacion de Google Ad Manager para Angular.
+ * Configuracion e inicializacion de Google AdSense para Angular.
  * Usa provideValtechAds() en el bootstrap de tu aplicacion.
  */
 import { EnvironmentProviders, InjectionToken } from '@angular/core';
-import { ValtechAdsConfig, LazyLoadConfig } from './types';
+import { ValtechAdsConfig } from './types';
 /**
  * Token de inyeccion para la configuracion de Ads.
  * Usado internamente por los servicios de ads.
  */
 export declare const VALTECH_ADS_CONFIG: InjectionToken<ValtechAdsConfig>;
-/**
- * Configuracion por defecto de lazy loading.
- */
-export declare const DEFAULT_LAZY_LOAD_CONFIG: LazyLoadConfig;
 /**
  * Configuracion por defecto del servicio de ads.
  */
@@ -22,42 +18,30 @@ export declare const DEFAULT_ADS_CONFIG: Partial<ValtechAdsConfig>;
 /**
  * Provee el servicio de Ads a la aplicacion Angular.
  *
- * @param config - Configuracion de Google Ad Manager
+ * @param config - Configuracion de Google AdSense
  * @returns EnvironmentProviders para usar en bootstrapApplication
  *
  * @example
  * ```typescript
  * // main.ts
  * import { bootstrapApplication } from '@angular/platform-browser';
- * import { provideValtechAds, provideValtechFirebase } from 'valtech-components';
- * import { environment } from './environments/environment';
+ * import { provideValtechAds } from 'valtech-components';
  *
  * bootstrapApplication(AppComponent, {
  *   providers: [
- *     // Firebase primero (para consent mode)
- *     provideValtechFirebase({
- *       firebase: environment.firebase,
- *       enableAnalytics: true,
- *     }),
- *
- *     // Luego Ads
  *     provideValtechAds({
- *       networkId: '/12345678',
- *       debugMode: !environment.production,
- *       isPremiumUser: () => inject(AuthService).hasRole('premium'),
+ *       adClient: 'ca-pub-XXXXXXXXXXXXXXXX',
+ *       testMode: true, // Usa ads de prueba en desarrollo
+ *       debugMode: true,
  *     }),
  *   ],
  * });
  * ```
  *
- * @example Con targeting global y rutas excluidas
+ * @example Con rutas excluidas
  * ```typescript
  * provideValtechAds({
- *   networkId: '/12345678',
- *   globalTargeting: {
- *     site: 'myvaltech',
- *     section: 'app',
- *   },
+ *   adClient: 'ca-pub-XXXXXXXXXXXXXXXX',
  *   excludeRoutes: [
  *     '^/checkout',
  *     '^/payment',

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

@@ -1,10 +1,9 @@
 /**
  * Ads Module
  *
- * Exports publicos para el servicio de Google Ad Manager.
+ * Exports publicos para el servicio de Google AdSense.
  */
-export { provideValtechAds, VALTECH_ADS_CONFIG, DEFAULT_ADS_CONFIG, DEFAULT_LAZY_LOAD_CONFIG } from './config';
+export { provideValtechAds, VALTECH_ADS_CONFIG, DEFAULT_ADS_CONFIG } from './config';
 export { AdsService } from './ads.service';
-export { AdsConsentService } from './ads-consent.service';
 export { AdsLoaderService } from './ads-loader.service';
-export { ValtechAdsConfig, LazyLoadConfig, AdSlotConfig, AdSlotSize, AD_SIZE_MAP, SizeMapping, AdSlotState, AdEvent, AdsConsentState, GPTSlot, GPTNamespace, GPTPubadsService, GPTSizeMappingBuilder, GPTEvent, } from './types';
+export { ValtechAdsConfig, AdSlotConfig, AdFormat, AdSlotState, AdEvent, AdsConsentState, AdSlotSize, AD_SIZE_MAP, SizeMapping, } from './types';

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

@@ -1,78 +1,45 @@
 /**
  * Ads Types
  *
- * Tipos e interfaces para el servicio de Google Ad Manager.
- * Usa Google Publisher Tags (GPT) para renderizar ads.
+ * Tipos e interfaces para el servicio de Google AdSense.
+ * Simplificado para usar AdSense en lugar de GPT (Ad Manager).
  */
 /**
  * Configuracion del servicio de Ads.
  * Pasada a provideValtechAds() en el bootstrap de la aplicacion.
  */
 export interface ValtechAdsConfig {
-    /** Network ID de Google Ad Manager (ej: '/12345678') */
-    networkId: string;
+    /** Publisher ID de AdSense (formato: ca-pub-XXXXXXXXXXXXXXXX) */
+    adClient: string;
     /** Habilitar modo debug (muestra info de ads en consola) */
     debugMode?: boolean;
-    /** Activar lazy loading de ads (viewport intersection) */
-    lazyLoad?: boolean;
-    /** Configuracion de lazy loading */
-    lazyLoadConfig?: LazyLoadConfig;
-    /** Configuracion por defecto para ad slots */
-    defaultSlotConfig?: Partial<AdSlotConfig>;
-    /** Targeting global (aplica a todos los slots) */
-    globalTargeting?: Record<string, string | string[]>;
-    /** Habilitar personalizacion de ads (requiere consent) */
-    enablePersonalization?: boolean;
-    /** Mostrar ads de fallback si no hay consent */
-    showNonPersonalizedAds?: boolean;
+    /** Test mode - usa ads de prueba durante desarrollo */
+    testMode?: boolean;
+    /** Habilitar Auto Ads (Google decide ubicacion automaticamente) */
+    autoAds?: boolean;
     /** Callback cuando se carga un ad */
     onAdLoaded?: (slotId: string, isEmpty: boolean) => void;
     /** Callback cuando falla un ad */
     onAdError?: (slotId: string, error: Error) => void;
-    /** Refresh automatico de ads (en segundos, 0 = deshabilitado) */
-    autoRefreshInterval?: number;
     /** Rutas donde NO mostrar ads (regex patterns) */
     excludeRoutes?: string[];
 }
 /**
- * Configuracion de lazy loading para GPT.
+ * Formato de ad para AdSense.
  */
-export interface LazyLoadConfig {
-    /** Margen del viewport para cargar (ej: '200px') */
-    rootMargin?: string;
-    /** Threshold de interseccion (0-1) */
-    threshold?: number;
-    /** Fetch margin para GPT (pixels antes del viewport) */
-    fetchMarginPercent?: number;
-    /** Render margin para GPT */
-    renderMarginPercent?: number;
-}
-/**
- * Tamanos de ad predefinidos (IAB standard).
- */
-export type AdSlotSize = 'leaderboard' | 'billboard' | 'medium-rectangle' | 'large-rectangle' | 'half-page' | 'skyscraper' | 'mobile-banner' | 'mobile-leaderboard' | 'fluid' | 'native' | 'custom';
-/**
- * Mapeo de tamanos predefinidos a dimensiones.
- */
-export declare const AD_SIZE_MAP: Record<AdSlotSize, [number, number] | 'fluid'>;
+export type AdFormat = 'auto' | 'fluid' | 'rectangle' | 'horizontal' | 'vertical';
 /**
  * Configuracion de un ad slot individual.
  */
 export interface AdSlotConfig {
     /** ID unico del slot (usado para el div container) */
     slotId: string;
-    /** Ad unit path (ej: '/homepage/top') - se concatena con networkId */
-    adUnitPath: string;
-    /** Tamano del ad o tamanos responsivos */
-    size: AdSlotSize | AdSlotSize[] | [number, number] | [number, number][];
-    /** Mapping responsivo: [viewport-width, sizes] */
-    sizeMapping?: SizeMapping[];
-    /** Targeting especifico para este slot */
-    targeting?: Record<string, string | string[]>;
-    /** Colapsar slot si esta vacio */
-    collapseEmpty?: boolean;
-    /** Es un native ad */
-    isNative?: boolean;
+    /** Ad Slot ID de AdSense (numero de unidad de anuncio) */
+    adSlot?: string;
+    /** Formato del ad */
+    format?: AdFormat;
+    /** Responsive - ocupa todo el ancho disponible */
+    fullWidth?: boolean;
     /** CSS class adicional */
     cssClass?: string;
     /** Altura minima mientras carga */
@@ -80,16 +47,6 @@ export interface AdSlotConfig {
     /** Mostrar skeleton mientras carga */
     showSkeleton?: boolean;
 }
-/**
- * Mapping de tamanos responsivos.
- * Define que tamanos de ad mostrar segun el viewport.
- */
-export interface SizeMapping {
-    /** Ancho minimo del viewport */
-    viewportWidth: number;
-    /** Tamanos de ad para este viewport */
-    sizes: ([number, number] | 'fluid')[];
-}
 /**
  * Estado de un ad slot.
  */
@@ -115,47 +72,25 @@ export interface AdsConsentState {
     /** Permite datos de usuario para ads */
     adUserData: boolean;
 }
-/** GPT Slot reference */
-export interface GPTSlot {
-    getSlotElementId(): string;
-    getAdUnitPath(): string;
-    addService(service: unknown): GPTSlot;
-    defineSizeMapping(mapping: unknown): GPTSlot;
-    setTargeting(key: string, value: string | string[]): GPTSlot;
-    setCollapseEmptyDiv(collapse: boolean, collapseBeforeAdFetch?: boolean): GPTSlot;
-}
-/** GPT global namespace (window.googletag) */
-export interface GPTNamespace {
-    cmd: Array<() => void>;
-    defineSlot(adUnitPath: string, size: unknown, divId: string): GPTSlot | null;
-    pubads(): GPTPubadsService;
-    enableServices(): void;
-    display(divId: string): void;
-    destroySlots(slots?: GPTSlot[]): boolean;
-    sizeMapping(): GPTSizeMappingBuilder;
-}
-/** GPT Pubads Service */
-export interface GPTPubadsService {
-    enableSingleRequest(): void;
-    enableLazyLoad(config?: object): void;
-    setTargeting(key: string, value: string | string[]): void;
-    setRequestNonPersonalizedAds(value: 0 | 1): void;
-    addEventListener(event: string, callback: (event: GPTEvent) => void): void;
-    refresh(slots?: GPTSlot[]): void;
-    collapseEmptyDivs(collapseBeforeAdFetch?: boolean): void;
-}
-/** GPT Size Mapping Builder */
-export interface GPTSizeMappingBuilder {
-    addSize(viewport: [number, number], sizes: unknown): GPTSizeMappingBuilder;
-    build(): unknown;
-}
-/** GPT Event */
-export interface GPTEvent {
-    slot: GPTSlot;
-    isEmpty?: boolean;
-}
+/** AdSense global array */
+export type AdSenseCommand = Record<string, unknown>;
 declare global {
     interface Window {
-        googletag?: GPTNamespace;
+        adsbygoogle?: AdSenseCommand[];
     }
 }
+/**
+ * @deprecated Use AdFormat instead
+ */
+export type AdSlotSize = 'leaderboard' | 'billboard' | 'medium-rectangle' | 'large-rectangle' | 'half-page' | 'skyscraper' | 'mobile-banner' | 'mobile-leaderboard' | 'fluid' | 'native' | 'custom';
+/**
+ * @deprecated AdSense handles sizes automatically
+ */
+export declare const AD_SIZE_MAP: Record<AdSlotSize, [number, number] | 'fluid'>;
+/**
+ * @deprecated Not used with AdSense
+ */
+export interface SizeMapping {
+    viewportWidth: number;
+    sizes: ([number, number] | 'fluid')[];
+}

package/lib/services/firebase/shared-config.d.ts

@@ -6,6 +6,7 @@
  * deben definirse en cada app consumidora.
  */
 import { AppId, EmulatorConfig, FirebaseConfig, ValtechFirebaseConfig } from './types';
+import type { AnalyticsConfig } from './analytics-types';
 export type { AppId } from './types';
 /**
  * Genera paths de Storage con namespace por app.
@@ -74,6 +75,16 @@ export interface CreateFirebaseConfigOptions {
      * Cuando se configura, FirestoreService y StorageService prefijan automáticamente los paths.
      */
     appId?: string;
+    /**
+     * Habilitar Firebase Analytics / GA4.
+     * Requiere measurementId en firebase config.
+     */
+    enableAnalytics?: boolean;
+    /**
+     * Configuración detallada de Analytics.
+     * Solo aplica si enableAnalytics es true.
+     */
+    analyticsConfig?: AnalyticsConfig;
 }
 /**
  * Crea la configuración completa de Firebase desde variables de entorno.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valtech-components",
-  "version": "2.0.503",
+  "version": "2.0.505",
   "private": false,
   "bin": {
     "valtech-firebase-config": "./src/lib/services/firebase/scripts/generate-sw-config.js"