multi-platform-tracking-sdk
Version:
🚀 Professional Multi-Platform Tracking SDK for Facebook/Meta Pixel, Instagram Analytics & Google Tag Manager | Zero Dependencies | TypeScript Ready | Privacy Compliant GDPR/CCPA | Created by A. Z. M. Arif | Code Encover
955 lines (946 loc) • 29.3 kB
TypeScript
interface ProductData {
id: string;
name?: string;
price: number;
quantity?: number;
currency?: string;
category?: string;
brand?: string;
variant?: string;
}
interface UserData {
email?: string;
phone?: string;
firstName?: string;
lastName?: string;
clientIpAddress?: string;
clientUserAgent?: string;
fbp?: string;
fbc?: string;
externalId?: string;
loginId?: string;
zipCode?: string;
city?: string;
state?: string;
country?: string;
dateOfBirth?: string;
gender?: 'M' | 'F' | 'm' | 'f';
subscriptionId?: string;
fbLoginId?: string;
leadId?: string;
f5first?: string;
f5last?: string;
fi?: string;
dobd?: string;
dobm?: string;
doby?: string;
madid?: string;
anonId?: string;
appUserId?: string;
ctwaClid?: string;
pageId?: string;
}
interface CustomData {
value?: number;
currency?: string;
contentName?: string;
contentCategory?: string;
contentIds?: string[];
contents?: Array<{
id: string;
quantity: number;
itemPrice?: number;
title?: string;
category?: string;
brand?: string;
}>;
contentType?: string;
orderId?: string;
searchString?: string;
status?: string;
numItems?: number;
deliveryCategory?: string;
customProperties?: {
[key: string]: unknown;
};
}
interface EventData {
eventName: string;
eventTime?: number;
eventId?: string;
eventSourceUrl?: string;
actionSource?: 'website' | 'email' | 'app' | 'phone_call' | 'chat' | 'physical_store' | 'system_generated' | 'other';
userData?: UserData;
customData?: CustomData;
testEventCode?: string;
}
interface ServerEventData extends EventData {
eventSourceUrl: string;
userData: UserData;
optOut?: boolean;
dataProcessingOptions?: string[];
dataProcessingOptionsCountry?: number;
dataProcessingOptionsState?: number;
}
interface MetaPixelConfig {
pixelId: string;
debug?: boolean;
autoInit?: boolean;
testEventCode?: string;
version?: string;
agent?: string;
}
interface ConversionAPIConfig {
accessToken: string;
pixelId: string;
debug?: boolean;
testEventCode?: string;
apiVersion?: string;
appSecret?: string;
partnerAgent?: string;
namespaceId?: string;
uploadId?: string;
uploadTag?: string;
uploadSource?: string;
}
interface HybridTrackerConfig {
pixelId: string;
serverEndpoint?: string;
debug?: boolean;
testEventCode?: string;
enableClientTracking?: boolean;
enableServerTracking?: boolean;
}
interface PurchaseData {
orderId: string;
value: number;
currency: string;
products: ProductData[];
eventId?: string;
customData?: CustomData;
}
interface CheckoutData {
value: number;
currency: string;
products: ProductData[];
eventId?: string;
customData?: CustomData;
}
interface SearchData {
searchTerm: string;
eventId?: string;
customData?: CustomData;
}
interface RegistrationData {
method?: string;
status?: string;
eventId?: string;
customData?: CustomData;
}
interface EventResponse {
eventsReceived?: number;
messages?: string[];
fbtrace_id?: string;
id?: string;
numProcessedEntries?: number;
events_received?: number;
}
interface TrackingError extends Error {
code?: string;
fbtrace_id?: string;
details?: unknown;
}
interface ValidationResult {
isValid: boolean;
errors: string[];
warnings: string[];
}
type EventName = 'PageView' | 'ViewContent' | 'Search' | 'AddToCart' | 'AddToWishlist' | 'InitiateCheckout' | 'AddPaymentInfo' | 'Purchase' | 'Lead' | 'CompleteRegistration' | 'Contact' | 'CustomizeProduct' | 'Donate' | 'FindLocation' | 'Schedule' | 'StartTrial' | 'SubmitApplication' | 'Subscribe' | string;
type Currency = 'USD' | 'EUR' | 'GBP' | 'CAD' | 'AUD' | 'JPY' | 'CNY' | 'INR' | 'BDT' | 'PKR' | 'NGN' | 'KES' | 'ZAR' | 'EGP' | string;
type ContentType = 'product' | 'product_group' | 'destination' | 'flight' | 'hotel' | 'vehicle' | string;
declare global {
interface Window {
fbq: FacebookPixelFunction;
fbevents?: Record<string, unknown>;
}
}
interface FacebookPixelFunction {
(...args: unknown[]): void;
callMethod?: ((...args: unknown[]) => void) | null;
queue?: unknown[];
loaded?: boolean;
version?: string | undefined;
agent?: string | undefined;
}
/**
* Meta Pixel (Facebook Pixel) client-side tracker
* Handles client-side tracking using the Facebook Pixel
*/
declare class MetaPixelTracker {
private config;
private isInitialized;
constructor(config: MetaPixelConfig);
/**
* Initialize the Meta Pixel
*/
init(): void;
/**
* Set up the Meta Pixel script and initialize fbq
*/
private setupPixel;
/**
* Enable debug mode for development
*/
private enableDebugMode;
/**
* Load the Facebook Pixel script
*/
private loadPixelScript;
/**
* Track a custom event
* @param eventName - Name of the event
* @param parameters - Event parameters
* @param eventId - Optional event ID for deduplication
*/
trackEvent(eventName: EventName, parameters?: Record<string, unknown>, eventId?: string): void;
/**
* Track page view
*/
trackPageView(): void;
/**
* Track product view
* @param product - Product data
*/
trackProductView(product: ProductData): void;
/**
* Track add to cart
* @param product - Product data
*/
trackAddToCart(product: ProductData): void;
/**
* Track initiate checkout
* @param data - Checkout data
*/
trackInitiateCheckout(data: CheckoutData): void;
/**
* Track purchase
* @param data - Purchase data
*/
trackPurchase(data: PurchaseData): void;
/**
* Track search
* @param data - Search data
*/
trackSearch(data: SearchData): void;
/**
* Track user registration
* @param data - Registration data
*/
trackRegistration(data?: RegistrationData): void;
/**
* Track add to wishlist
* @param product - Product data
*/
trackAddToWishlist(product: ProductData): void;
/**
* Track lead generation
* @param data - Lead data
*/
trackLead(data?: Record<string, unknown>): void;
/**
* Get current configuration
*/
getConfig(): MetaPixelConfig;
/**
* Check if pixel is initialized
*/
isReady(): boolean;
/**
* Update configuration (requires re-initialization)
* @param newConfig - New configuration
*/
updateConfig(newConfig: Partial<MetaPixelConfig>): void;
}
/**
* Meta Conversion API server-side tracker
* Self-contained implementation inspired by facebook-nodejs-business-sdk patterns
* Handles server-side tracking using Facebook's Conversion API without external dependencies
*/
declare class MetaConversionTracker {
private config;
private retryAttempts;
private retryDelay;
private baseUrl;
constructor(config: ConversionAPIConfig);
/**
* Make HTTP request to Facebook Conversion API
*/
private makeRequest;
/**
* Generate HMAC-SHA256 signature for app secret proof
*/
private generateSignature;
/**
* Send a single event to Facebook Conversion API
*/
sendEvent(eventData: ServerEventData): Promise<EventResponse>;
/**
* Send multiple events in a batch
*/
sendBatchEvents(events: ServerEventData[]): Promise<EventResponse>;
/**
* Create server event object
*/
private createServerEvent;
/**
* Create and populate user data object
*/
private createUserData;
/**
* Create custom data object
*/
private createCustomData;
/**
* Transform API response to our format
*/
private transformResponse;
/**
* Validate server event data
*/
private validateServerEventData;
/**
* Test connection to Facebook Conversion API
*/
testConnection(): Promise<{
success: boolean;
details?: unknown;
error?: string;
}>;
/**
* Validate pixel access
*/
validatePixelAccess(): Promise<{
valid: boolean;
permissions?: string[];
error?: string;
}>;
/**
* Get recommended events for business type
*/
getRecommendedEvents(businessType: 'ecommerce' | 'saas' | 'lead_generation' | 'content' | 'app'): EventName[];
/**
* Quick tracking methods
*/
trackPageView(userData?: UserData, customData?: CustomData): Promise<EventResponse>;
trackPurchase(value: number, currency?: string, userData?: UserData, additionalData?: Partial<CustomData>): Promise<EventResponse>;
trackLead(userData?: UserData, customData?: CustomData): Promise<EventResponse>;
trackAddToCart(contentIds: string[], value?: number, currency?: string, userData?: UserData, additionalData?: Partial<CustomData>): Promise<EventResponse>;
trackViewContent(contentId: string, contentType?: string, value?: number, currency?: string, userData?: UserData, additionalData?: Partial<CustomData>): Promise<EventResponse>;
/**
* Update configuration
*/
updateConfig(newConfig: Partial<ConversionAPIConfig>): void;
/**
* Get current configuration (without sensitive data)
*/
getConfig(): Record<string, unknown>;
}
/**
* Hybrid tracker that combines client-side (Meta Pixel) and server-side tracking
* Provides maximum tracking reliability and coverage
*/
declare class HybridTracker {
private config;
private pixelTracker?;
constructor(config: HybridTrackerConfig);
/**
* Send event to server endpoint for server-side tracking
* @param eventData - Event data to send to server
* @returns Promise with success status
*/
private sendToServer;
/**
* Track event on both client and server
* @param clientTrackingFn - Function to execute client-side tracking
* @param serverEventData - Data to send to server for server-side tracking
*/
private trackHybrid;
/**
* Track page view
*/
trackPageView(): Promise<void>;
/**
* Track product view
* @param product - Product data
*/
trackProductView(product: ProductData): Promise<void>;
/**
* Track add to cart
* @param product - Product data
*/
trackAddToCart(product: ProductData): Promise<void>;
/**
* Track initiate checkout
* @param data - Checkout data
*/
trackInitiateCheckout(data: CheckoutData): Promise<void>;
/**
* Track purchase
* @param data - Purchase data
*/
trackPurchase(data: PurchaseData): Promise<void>;
/**
* Track search
* @param data - Search data
*/
trackSearch(data: SearchData): Promise<void>;
/**
* Track user registration
* @param data - Registration data
*/
trackRegistration(data?: RegistrationData): Promise<void>;
/**
* Track add to wishlist
* @param product - Product data
*/
trackAddToWishlist(product: ProductData): Promise<void>;
/**
* Track lead generation
* @param data - Lead data
*/
trackLead(data?: Record<string, unknown>): Promise<void>;
/**
* Track custom event
* @param eventName - Event name
* @param parameters - Event parameters
* @param eventId - Optional event ID
*/
trackCustomEvent(eventName: string, parameters?: Record<string, unknown>, eventId?: string): Promise<void>;
/**
* Get current configuration
*/
getConfig(): HybridTrackerConfig;
/**
* Update configuration
* @param newConfig - New configuration
*/
updateConfig(newConfig: Partial<HybridTrackerConfig>): void;
/**
* Enable/disable client-side tracking
* @param enabled - Whether to enable client-side tracking
*/
setClientTrackingEnabled(enabled: boolean): void;
/**
* Enable/disable server-side tracking
* @param enabled - Whether to enable server-side tracking
*/
setServerTrackingEnabled(enabled: boolean): void;
/**
* Check if client-side tracking is ready
*/
isClientTrackingReady(): boolean;
/**
* Check if server-side tracking is configured
*/
isServerTrackingConfigured(): boolean;
/**
* Get tracking status
*/
getTrackingStatus(): {
clientTracking: boolean;
serverTracking: boolean;
pixelReady: boolean;
serverConfigured: boolean;
};
}
interface GTMConfig {
/** Google Tag Manager Container ID */
gtmId: string;
/** Enable debug mode for development */
debug?: boolean;
/** Automatically track page views */
autoTrackPageViews?: boolean;
/** Custom data layer name (default: 'dataLayer') */
dataLayerName?: string;
/** Currency to use for ecommerce events */
defaultCurrency?: string;
}
declare global {
interface Window {
dataLayer: Record<string, unknown>[];
[key: string]: unknown;
}
}
/**
* Google Tag Manager tracker for comprehensive analytics
* Supports GA4, Facebook Pixel, and other tracking through GTM
*/
declare class GTMTracker {
private config;
private isInitialized;
private dataLayerName;
constructor(config: GTMConfig);
/**
* Initialize Google Tag Manager
*/
init(): void;
/**
* Initialize data layer
*/
private initDataLayer;
/**
* Enable debug mode for development
*/
private enableDebugMode;
/**
* Load Google Tag Manager script
*/
private loadGTMScript;
/**
* Add noscript fallback for users with JavaScript disabled
*/
private addNoScriptFallback;
/**
* Push event to data layer
*/
private pushEvent;
/**
* Track page view
*/
trackPageView(url?: string, title?: string): void;
/**
* Track product view
*/
trackProductView(product: ProductData): void;
/**
* Track add to cart
*/
trackAddToCart(product: ProductData): void;
/**
* Track initiate checkout
*/
trackInitiateCheckout(data: CheckoutData): void;
/**
* Track purchase
*/
trackPurchase(data: PurchaseData): void;
/**
* Track search
*/
trackSearch(data: SearchData): void;
/**
* Track user registration
*/
trackRegistration(data?: RegistrationData): void;
/**
* Track custom event
*/
trackCustomEvent(eventName: string, parameters?: Record<string, unknown>): void;
/**
* Set user data
*/
setUserData(userData: {
userId?: string;
userType?: string;
email?: string;
isLoggedIn: boolean;
}): void;
/**
* Track add to wishlist
*/
trackAddToWishlist(product: ProductData): void;
/**
* Debug data layer contents
*/
debugDataLayer(): void;
/**
* Check if GTM is initialized
*/
isReady(): boolean;
/**
* Get current configuration
*/
getConfig(): GTMConfig;
/**
* Update configuration
*/
updateConfig(newConfig: Partial<GTMConfig>): void;
}
/**
* Instagram Tracking SDK
*
* Instagram uses the same Facebook/Meta Pixel and Conversion API infrastructure
* but with Instagram-specific parameters and tracking patterns.
*
* This tracker extends the existing Meta tracking capabilities with
* Instagram-specific features and optimizations.
*/
interface InstagramEngagementData {
contentType?: 'photo' | 'video' | 'carousel' | 'story' | 'reel' | 'igtv';
contentId?: string;
contentName?: string;
contentCategory?: string;
creatorId?: string;
creatorName?: string;
hashtags?: string[];
location?: string;
duration?: number;
isSponsored?: boolean;
campaignId?: string;
}
interface InstagramShoppingData {
productId: string;
productName?: string;
price: number;
currency?: string;
category?: string;
brand?: string;
availability?: 'in_stock' | 'out_of_stock' | 'preorder';
imageUrl?: string;
productUrl?: string;
merchantId?: string;
catalogId?: string;
isFromShop?: boolean;
shoppingSource?: 'feed' | 'story' | 'explore' | 'search' | 'profile';
}
interface InstagramUserData {
userId?: string;
username?: string;
isFollower?: boolean;
followersCount?: number;
accountType?: 'personal' | 'business' | 'creator';
verificationStatus?: 'verified' | 'unverified';
interests?: string[];
demographics?: {
age?: number;
gender?: 'male' | 'female' | 'other';
location?: string;
language?: string;
};
}
interface InstagramConfig {
pixelId: string;
accessToken?: string;
debug?: boolean;
instagramAppId?: string;
enableInstagramAPI?: boolean;
defaultCurrency?: string;
testEventCode?: string;
}
declare class InstagramTracker {
private pixelTracker;
private conversionTracker?;
private config;
constructor(config: InstagramConfig);
/**
* Initialize Instagram tracking
*/
init(): void;
/**
* Set Instagram-specific context for tracking
*/
private setInstagramContext;
/**
* Track Instagram content engagement
*/
trackContentEngagement(action: 'like' | 'comment' | 'share' | 'save' | 'view' | 'click', data?: InstagramEngagementData): void;
/**
* Track Instagram Story interaction
*/
trackStoryInteraction(action: 'view' | 'tap_next' | 'tap_back' | 'tap_exit' | 'swipe_up' | 'reply', data?: InstagramEngagementData): void;
/**
* Track Instagram Reels interaction
*/
trackReelsInteraction(action: 'view' | 'like' | 'comment' | 'share' | 'save' | 'follow', data?: InstagramEngagementData): void;
/**
* Track Instagram Shopping events
*/
trackShoppingEvent(action: 'product_view' | 'add_to_cart' | 'add_to_wishlist' | 'purchase' | 'shop_visit', data: InstagramShoppingData): void;
/**
* Track Instagram user follow/unfollow
*/
trackFollowAction(action: 'follow' | 'unfollow', targetUser: {
userId?: string;
username?: string;
accountType?: 'personal' | 'business' | 'creator';
}): void;
/**
* Track Instagram search
*/
trackSearch(searchTerm: string, searchType?: 'hashtag' | 'user' | 'place' | 'general'): void;
/**
* Track Instagram Live interaction
*/
trackLiveInteraction(action: 'start_watching' | 'stop_watching' | 'comment' | 'like' | 'share', data?: {
liveId?: string;
creatorId?: string;
viewerCount?: number;
duration?: number;
}): void;
/**
* Track Instagram ad interaction
*/
trackAdInteraction(action: 'view' | 'click' | 'like' | 'comment' | 'share' | 'save' | 'hide', adData?: {
adId?: string;
campaignId?: string;
adSetId?: string;
adType?: 'photo' | 'video' | 'carousel' | 'story' | 'reel';
placementType?: 'feed' | 'story' | 'explore' | 'reel';
}): void;
/**
* Set Instagram user context
*/
setUserContext(userData: InstagramUserData): void;
/**
* Track Instagram profile visit
*/
trackProfileVisit(profileData: {
userId?: string;
username?: string;
accountType?: 'personal' | 'business' | 'creator';
isOwn?: boolean;
}): void;
/**
* Track Instagram hashtag interaction
*/
trackHashtagInteraction(action: 'view' | 'follow' | 'unfollow', hashtag: string): void;
/**
* Track Instagram direct message interaction
*/
trackDirectMessage(action: 'send' | 'receive' | 'read' | 'react', messageData?: {
conversationId?: string;
messageType?: 'text' | 'photo' | 'video' | 'voice' | 'story_reply';
isGroupMessage?: boolean;
}): void;
/**
* Get configuration
*/
getConfig(): InstagramConfig;
/**
* Update configuration
*/
updateConfig(newConfig: Partial<InstagramConfig>): void;
/**
* Check if tracker is ready
*/
isReady(): boolean;
/**
* Get Instagram-specific recommendations based on account type
*/
getRecommendedEvents(accountType?: 'personal' | 'business' | 'creator'): string[];
/**
* Debug Instagram tracking data
*/
debugInstagramData(): void;
}
/**
* Utility functions for multi platform tracking sdk
*/
/**
* Hash user data using SHA256 as required by Facebook Conversion API
* Uses crypto module in Node.js or SubtleCrypto in browsers
* @param data - The data to hash
* @returns Hashed data in hexadecimal format
*/
declare function hashData(data: string): Promise<string>;
/**
* Synchronous version of hashData for compatibility
* Uses simple hash in browsers, crypto in Node.js
* @param data - The data to hash
* @returns Hashed data in hexadecimal format
*/
declare function hashDataSync(data: string): string;
/**
* Normalize and hash user data for privacy compliance
* @param userData - User data to normalize and hash
* @returns Normalized and hashed user data
*/
declare function normalizeUserData(userData: UserData): UserData;
/**
* Generate a unique event ID
* @param prefix - Optional prefix for the event ID
* @returns Unique event ID
*/
declare function generateEventId(prefix?: string): string;
/**
* Get current timestamp in Unix seconds
* @returns Current timestamp in seconds
*/
declare function getCurrentTimestamp(): number;
/**
* Validate pixel ID format
* @param pixelId - The pixel ID to validate
* @returns True if valid, false otherwise
*/
declare function isValidPixelId(pixelId: string): boolean;
/**
* Validate access token format (basic validation)
* @param accessToken - The access token to validate
* @returns True if valid format, false otherwise
*/
declare function isValidAccessToken(accessToken: string): boolean;
/**
* Validate email format
* @param email - The email to validate
* @returns True if valid email format, false otherwise
*/
declare function isValidEmail(email: string): boolean;
/**
* Validate phone number format (international)
* @param phone - The phone number to validate
* @returns True if valid phone format, false otherwise
*/
declare function isValidPhone(phone: string): boolean;
/**
* Validate currency code (ISO 4217)
* @param currency - The currency code to validate
* @returns True if valid currency code, false otherwise
*/
declare function isValidCurrency(currency: string): boolean;
/**
* Validate event configuration
* @param config - Configuration object to validate
* @returns Validation result with errors and warnings
*/
declare function validateConfig(config: Record<string, unknown> | MetaPixelConfig | ConversionAPIConfig | HybridTrackerConfig): ValidationResult;
/**
* Sanitize URL for tracking
* @param url - URL to sanitize
* @returns Sanitized URL
*/
declare function sanitizeUrl(url: string): string;
/**
* Deep clone an object (for avoiding mutations)
* @param obj - Object to clone
* @returns Deep cloned object
*/
declare function deepClone<T>(obj: T): T;
/**
* Retry function with exponential backoff
* @param fn - Function to retry
* @param maxRetries - Maximum number of retries
* @param delay - Initial delay in milliseconds
* @returns Promise that resolves with function result or rejects after max retries
*/
declare function retry<T>(fn: () => Promise<T>, maxRetries?: number, delay?: number): Promise<T>;
/**
* Create a tracking error with additional context
* @param message - Error message
* @param code - Error code
* @param details - Additional error details
* @returns Formatted tracking error
*/
declare function createTrackingError(message: string, code?: string, details?: unknown): TrackingError;
/**
* Check if code is running in browser environment
* @returns True if in browser, false otherwise
*/
declare function isBrowser(): boolean;
/**
* Check if code is running in Node.js environment
* @returns True if in Node.js, false otherwise
*/
declare function isNode(): boolean;
/**
* Safely get nested object property
* @param obj - Object to get property from
* @param path - Property path (e.g., 'user.profile.name')
* @param defaultValue - Default value if property doesn't exist
* @returns Property value or default value
*/
declare function safeGet(obj: Record<string, unknown>, path: string, defaultValue?: unknown): unknown;
declare const VERSION = "1.1.0";
declare const PACKAGE_NAME = "@azmarifdev/multi-platform-tracking-sdk";
/**
* Quick setup functions for common use cases
*/
/**
* Quick setup for client-side tracking only
* @param pixelId - Facebook Pixel ID
* @param options - Optional configuration
* @returns Configured MetaPixelTracker instance
*/
declare function createPixelTracker(pixelId: string, options?: Partial<Omit<MetaPixelConfig, 'pixelId'>>): MetaPixelTracker;
/**
* Quick setup for server-side tracking only
* @param accessToken - Facebook API access token
* @param pixelId - Facebook Pixel ID
* @param options - Optional configuration
* @returns Configured MetaConversionTracker instance
*/
declare function createConversionTracker(accessToken: string, pixelId: string, options?: Partial<Omit<ConversionAPIConfig, 'accessToken' | 'pixelId'>>): MetaConversionTracker;
/**
* Quick setup for hybrid tracking (client + server)
* @param pixelId - Facebook Pixel ID
* @param serverEndpoint - Server endpoint for server-side tracking
* @param options - Optional configuration
* @returns Configured HybridTracker instance
*/
declare function createHybridTracker(pixelId: string, serverEndpoint?: string, options?: Partial<Omit<HybridTrackerConfig, 'pixelId' | 'serverEndpoint'>>): HybridTracker;
/**
* Quick setup for Google Tag Manager tracking
* @param gtmId - Google Tag Manager Container ID
* @param options - Optional configuration
* @returns Configured GTMTracker instance
*/
declare function createGTMTracker(gtmId: string, options?: Partial<Omit<GTMConfig, 'gtmId'>>): GTMTracker;
/**
* Quick setup for Instagram tracking
* @param pixelId - Facebook Pixel ID (Instagram uses same pixel)
* @param options - Optional configuration
* @returns Configured InstagramTracker instance
*/
declare function createInstagramTracker(pixelId: string, options?: Partial<Omit<InstagramConfig, 'pixelId'>>): InstagramTracker;
/**
* Set the global tracker instance for convenience functions
* @param tracker - Tracker instance to use globally
*/
declare function setGlobalTracker(tracker: MetaPixelTracker): void;
/**
* Get the current global tracker instance
* @returns Current global tracker or null
*/
declare function getGlobalTracker(): MetaPixelTracker | null;
/**
* Convenience function to track page view
* Requires global tracker to be set
*/
declare function trackPageView(): void;
/**
* Convenience function to track product view
* Requires global tracker to be set
* @param product - Product data
*/
declare function trackProductView(product: ProductData): void;
/**
* Convenience function to track add to cart
* Requires global tracker to be set
* @param product - Product data
*/
declare function trackAddToCart(product: ProductData): void;
/**
* Convenience function to track purchase
* Requires global tracker to be set
* @param data - Purchase data
*/
declare function trackPurchase(data: PurchaseData): void;
/**
* Convenience function to track search
* Requires global tracker to be set
* @param data - Search data
*/
declare function trackSearch(data: SearchData): void;
/**
* SDK Information
*/
declare const SDK_INFO: {
readonly name: "@azmarifdev/multi-platform-tracking-sdk";
readonly version: "1.1.0";
readonly author: "A. Z. M. Arif";
readonly license: "MIT";
readonly repository: "https://github.com/azmarifdev/multi-platform-tracking-sdk";
readonly homepage: "https://github.com/azmarifdev/multi-platform-tracking-sdk#readme";
readonly bugs: "https://github.com/azmarifdev/multi-platform-tracking-sdk/issues";
};
export { GTMTracker, HybridTracker, InstagramTracker, MetaConversionTracker, MetaPixelTracker, PACKAGE_NAME, SDK_INFO, VERSION, createConversionTracker, createGTMTracker, createHybridTracker, createInstagramTracker, createPixelTracker, createTrackingError, deepClone, MetaPixelTracker as default, generateEventId, getCurrentTimestamp, getGlobalTracker, hashData, hashDataSync, isBrowser, isNode, isValidAccessToken, isValidCurrency, isValidEmail, isValidPhone, isValidPixelId, normalizeUserData, retry, safeGet, sanitizeUrl, setGlobalTracker, trackAddToCart, trackPageView, trackProductView, trackPurchase, trackSearch, validateConfig };
export type { CheckoutData, ContentType, ConversionAPIConfig, Currency, CustomData, EventData, EventName, EventResponse, GTMConfig, HybridTrackerConfig, InstagramConfig, InstagramEngagementData, InstagramShoppingData, InstagramUserData, MetaPixelConfig, ProductData, PurchaseData, RegistrationData, SearchData, ServerEventData, TrackingError, UserData, ValidationResult };