valtech-components 2.0.500 → 2.0.502

package/lib/components/atoms/button/button.component.d.ts

@@ -1,10 +1,10 @@
-import { EventEmitter, OnInit } from '@angular/core';
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
 import { DownloadService } from '../../../services/download.service';
 import { IconService } from '../../../services/icons.service';
 import { NavigationService } from '../../../services/navigation.service';
 import { ButtonMetadata } from '../../types';
 import * as i0 from "@angular/core";
-export declare class ButtonComponent implements OnInit {
+export declare class ButtonComponent implements OnInit, OnChanges {
     private download;
     private navigation;
     states: {
@@ -13,19 +13,43 @@ export declare class ButtonComponent implements OnInit {
         WORKING: "WORKING";
         ERROR: "ERROR";
     };
+    private presets;
     /**
      * The text to display on the button.
      */
     displayText: string;
-    props: ButtonMetadata;
+    /**
+     * Preset name to apply. Presets define reusable button configurations
+     * (size, color, fill, etc.) that can be registered at app level.
+     *
+     * @example
+     * <val-button preset="primary-action" [props]="{ text: 'Save' }"></val-button>
+     */
+    preset?: string;
+    /**
+     * Button configuration. Values here override preset values.
+     * When using presets, only partial props are needed (preset provides defaults).
+     */
+    props: Partial<ButtonMetadata>;
+    /**
+     * Resolved props after merging preset + explicit props.
+     * Preset values are overridden by explicit props.
+     */
+    resolvedProps: ButtonMetadata;
     /**
      * Event emitted when the button is clicked.
      */
     onClick: EventEmitter<string>;
-    constructor(download: DownloadService, icon: IconService, navigation: NavigationService);
+    constructor(download: DownloadService, _icon: IconService, navigation: NavigationService);
     ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Merge preset configuration with explicit props.
+     * Explicit props take precedence over preset values.
+     */
+    private resolveProps;
     /**
-     * Set up the text content based on the props configuration.
+     * Set up the text content based on the resolved props configuration.
      */
     private setupDisplayText;
     /**
@@ -35,5 +59,5 @@ export declare class ButtonComponent implements OnInit {
     private interpolateContent;
     clickHandler(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "val-button", never, { "props": { "alias": "props"; "required": false; }; }, { "onClick": "onClick"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "val-button", never, { "preset": { "alias": "preset"; "required": false; }; "props": { "alias": "props"; "required": false; }; }, { "onClick": "onClick"; }, never, never, true, never>;
 }

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

@@ -0,0 +1,78 @@
+/**
+ * Ad Slot Component
+ *
+ * Componente standalone para mostrar ads de Google Ad Manager.
+ * Se integra automaticamente con el servicio de Ads y respeta consent + premium.
+ *
+ * @example
+ * ```html
+ * <!-- Banner basico -->
+ * <val-ad-slot
+ *   slotId="homepage-top"
+ *   adUnitPath="/homepage/top"
+ *   size="leaderboard"
+ * />
+ *
+ * <!-- Con responsivo -->
+ * <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]] }
+ *   ]"
+ * />
+ *
+ * <!-- Native ad -->
+ * <val-ad-slot
+ *   slotId="article-native"
+ *   adUnitPath="/article/native"
+ *   size="native"
+ *   [isNative]="true"
+ * />
+ * ```
+ */
+import { OnInit, OnDestroy } from '@angular/core';
+import { AdsService } from '../../../services/ads/ads.service';
+import { AdSlotSize, AdSlotState, SizeMapping } from '../../../services/ads/types';
+import * as i0 from "@angular/core";
+export declare class AdSlotComponent implements OnInit, OnDestroy {
+    readonly adsService: AdsService;
+    private readonly platformId;
+    /** ID unico del slot */
+    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;
+    /** CSS class adicional */
+    cssClass: string;
+    /** Altura minima */
+    minHeight: string;
+    /** Mostrar skeleton */
+    showSkeleton: boolean;
+    private readonly _state;
+    readonly state: import("@angular/core").Signal<AdSlotState>;
+    /** 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>;
+    ngOnDestroy(): void;
+    private initializeSlot;
+    private getFirstSize;
+    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>;
+}

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

@@ -0,0 +1,59 @@
+import { AdsConsentState } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que maneja el consent para ads.
+ *
+ * Se integra con AnalyticsService para reutilizar el estado de consent GDPR.
+ * Si AnalyticsService no esta disponible, usa valores por defecto conservadores.
+ */
+export declare class AdsConsentService {
+    private readonly platformId;
+    private readonly injector;
+    private readonly _consentState;
+    /** Estado de consent para ads (readonly) */
+    readonly adsConsentState: import("@angular/core").Signal<AdsConsentState>;
+    /** Indica si se pueden mostrar ads (al menos consent basico) */
+    readonly canShowAds: import("@angular/core").Signal<boolean>;
+    /** Indica si se pueden mostrar ads personalizados */
+    readonly canPersonalize: import("@angular/core").Signal<boolean>;
+    private analyticsService;
+    private consentSyncInterval;
+    constructor();
+    /**
+     * Inicializa la sincronizacion con AnalyticsService.
+     */
+    private initializeConsentSync;
+    /**
+     * Sincroniza el estado de consent desde AnalyticsService.
+     */
+    private syncWithAnalyticsConsent;
+    /**
+     * Actualiza el estado de consent desde AnalyticsService.
+     */
+    private updateFromAnalyticsConsent;
+    /**
+     * Establece consent por defecto (sin datos personales).
+     */
+    private setDefaultConsent;
+    /**
+     * Actualiza manualmente el consent para ads.
+     * Usar cuando el usuario actualiza sus preferencias directamente.
+     *
+     * @param consent - Nuevo estado de consent parcial
+     */
+    updateConsent(consent: Partial<AdsConsentState>): void;
+    /**
+     * Aplica el estado de consent actual a GPT.
+     */
+    applyConsentToGPT(): void;
+    /**
+     * Obtiene el estado actual de consent.
+     */
+    getConsentState(): AdsConsentState;
+    /**
+     * Destruye el servicio y limpia recursos.
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdsConsentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdsConsentService>;
+}

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

@@ -0,0 +1,46 @@
+import { ValtechAdsConfig, GPTNamespace } from './types';
+import { AdsConsentService } from './ads-consent.service';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para cargar el script de Google Publisher Tags.
+ *
+ * Implementa lazy loading: el script solo se carga cuando
+ * se solicita renderizar el primer ad slot.
+ */
+export declare class AdsLoaderService {
+    private config;
+    private platformId;
+    private consentService;
+    private readonly _isLoading;
+    private readonly _isLoaded;
+    private readonly _error;
+    /** Indica si el script esta cargando */
+    readonly isLoading: import("@angular/core").Signal<boolean>;
+    /** Indica si el script esta cargado */
+    readonly isLoaded: import("@angular/core").Signal<boolean>;
+    /** Error de carga (si existe) */
+    readonly error: import("@angular/core").Signal<Error>;
+    private loadPromise;
+    constructor(config: ValtechAdsConfig, platformId: Object, consentService: AdsConsentService);
+    /**
+     * Carga el script GPT de forma lazy.
+     * Retorna la instancia de googletag o null si falla.
+     *
+     * @returns Promise con googletag o null
+     */
+    loadGPT(): Promise<GPTNamespace | null>;
+    /**
+     * Configura GPT con las opciones de la aplicacion.
+     */
+    private configureGPT;
+    /**
+     * Verifica si el script GPT esta disponible.
+     */
+    isGPTAvailable(): boolean;
+    /**
+     * Obtiene la instancia de googletag si esta cargada.
+     */
+    getGPT(): GPTNamespace | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdsLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdsLoaderService>;
+}

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

@@ -0,0 +1,123 @@
+/**
+ * Ads Service
+ *
+ * Servicio principal para Google Ad Manager (GPT).
+ * Integra con el sistema de consent existente y respeta usuarios premium.
+ */
+import { Injector, 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 * as i0 from "@angular/core";
+/**
+ * Servicio principal de Google Ad Manager.
+ *
+ * Maneja la creacion, destruccion y refresh de ad slots.
+ * Integra automaticamente con consent mode y detecta usuarios premium.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class MyComponent {
+ *   private ads = inject(AdsService);
+ *
+ *   // Verificar si mostrar ads
+ *   showAds = this.ads.isEnabled;
+ *
+ *   // Verificar si usuario es premium
+ *   isPremium = this.ads.isPremiumUser;
+ * }
+ * ```
+ */
+export declare class AdsService implements OnDestroy {
+    private injector;
+    private config;
+    private platformId;
+    private router;
+    private loaderService;
+    private consentService;
+    private readonly _isInitialized;
+    private readonly _isEnabled;
+    private readonly _isPremiumUser;
+    private readonly _isDebugMode;
+    private readonly _slots;
+    private readonly _slotStates;
+    private readonly _events;
+    /** Indica si el servicio esta inicializado */
+    readonly isInitialized: import("@angular/core").Signal<boolean>;
+    /** Indica si los ads estan habilitados (consent + no premium) */
+    readonly isEnabled: import("@angular/core").Signal<boolean>;
+    /** 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>;
+    /** Eventos de ads (historial) */
+    readonly events: import("@angular/core").Signal<AdEvent[]>;
+    private activeSlots;
+    private routerSubscription;
+    private refreshTimerId;
+    constructor(injector: Injector, config: ValtechAdsConfig, platformId: Object, router: Router, loaderService: AdsLoaderService, consentService: AdsConsentService);
+    /**
+     * Inicializa el servicio de ads.
+     * Llamado automaticamente por APP_INITIALIZER.
+     * NO carga el script GPT hasta que se necesite el primer ad.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Carga el script GPT de forma lazy.
+     * Llamado automaticamente cuando se renderiza el primer ad slot.
+     */
+    ensureGPTLoaded(): Promise<GPTNamespace | null>;
+    /**
+     * Define y muestra 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
+     */
+    defineSlot(config: AdSlotConfig): Promise<string | null>;
+    /**
+     * Destruye un slot y libera recursos.
+     *
+     * @param slotId - ID del slot a destruir
+     */
+    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;
+    /**
+     * Obtiene el estado de un slot.
+     *
+     * @param slotId - ID del slot
+     * @returns Estado actual del slot
+     */
+    getSlotState(slotId: string): AdSlotState;
+    /**
+     * Actualiza el estado premium del usuario.
+     * Llamar cuando cambie el estado de suscripcion.
+     *
+     * @param isPremium - Nuevo estado premium
+     */
+    updatePremiumStatus(isPremium: boolean): void;
+    /**
+     * Destruye todos los slots activos.
+     */
+    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>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdsService>;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Ads Configuration
+ *
+ * Configuracion e inicializacion de Google Ad Manager para Angular.
+ * Usa provideValtechAds() en el bootstrap de tu aplicacion.
+ */
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { ValtechAdsConfig, LazyLoadConfig } 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.
+ */
+export declare const DEFAULT_ADS_CONFIG: Partial<ValtechAdsConfig>;
+/**
+ * Provee el servicio de Ads a la aplicacion Angular.
+ *
+ * @param config - Configuracion de Google Ad Manager
+ * @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';
+ *
+ * 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'),
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @example Con targeting global y rutas excluidas
+ * ```typescript
+ * provideValtechAds({
+ *   networkId: '/12345678',
+ *   globalTargeting: {
+ *     site: 'myvaltech',
+ *     section: 'app',
+ *   },
+ *   excludeRoutes: [
+ *     '^/checkout',
+ *     '^/payment',
+ *     '^/premium',
+ *   ],
+ * })
+ * ```
+ */
+export declare function provideValtechAds(config: ValtechAdsConfig): EnvironmentProviders;

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

@@ -0,0 +1,10 @@
+/**
+ * Ads Module
+ *
+ * Exports publicos para el servicio de Google Ad Manager.
+ */
+export { provideValtechAds, VALTECH_ADS_CONFIG, DEFAULT_ADS_CONFIG, DEFAULT_LAZY_LOAD_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';

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

@@ -0,0 +1,163 @@
+/**
+ * Ads Types
+ *
+ * Tipos e interfaces para el servicio de Google Ad Manager.
+ * Usa Google Publisher Tags (GPT) para renderizar ads.
+ */
+/**
+ * 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;
+    /** 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;
+    /** Funcion para determinar si el usuario es premium (sin ads) */
+    isPremiumUser?: () => boolean;
+    /** 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;
+    /** 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.
+ */
+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'>;
+/**
+ * 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;
+    /** CSS class adicional */
+    cssClass?: string;
+    /** Altura minima mientras carga */
+    minHeight?: string;
+    /** 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.
+ */
+export type AdSlotState = 'idle' | 'loading' | 'rendered' | 'empty' | 'hidden' | 'error';
+/**
+ * Evento emitido por el servicio de ads.
+ */
+export interface AdEvent {
+    type: 'loaded' | 'empty' | 'error' | 'viewable' | 'clicked';
+    slotId: string;
+    timestamp: Date;
+    isEmpty?: boolean;
+    error?: Error;
+}
+/**
+ * Estado de consent para ads (mapeado desde AnalyticsService).
+ */
+export interface AdsConsentState {
+    /** Permite almacenamiento de ads */
+    adStorage: boolean;
+    /** Permite personalizacion de ads */
+    adPersonalization: boolean;
+    /** 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;
+}
+declare global {
+    interface Window {
+        googletag?: GPTNamespace;
+    }
+}

package/package.json

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

package/public-api.d.ts

@@ -221,6 +221,8 @@ export * from './lib/services/firebase';
 export * from './lib/services/auth';
 export * from './lib/services/i18n';
 export * from './lib/services/presets';
+export * from './lib/services/ads';
+export * from './lib/components/molecules/ad-slot/ad-slot.component';
 export * from './lib/components/types';
 export * from './lib/shared/pipes/process-links.pipe';
 export * from './lib/shared/utils/dom';