TLT.init({
   /**
    * Base configuration for the core.
    * It specifies which modules should listen to which events, which frames
    * to ignore, which elements to block, and which links are excluded from
    * triggering an unload.
    * @type {Object}
    */
   core: {
       /**
        * Use this to add a custom note which will be available for eventing
        * in the session data.
        */
      buildNote: "r3 MP 12/7/2020",
     
       /**
        * The ieExcludedLinks entry specifies a set of links that should
        * not trigger the beforeunload event, which destroys the UI
        * Capture library. This addresses a known issue with Internet
        * Explorer. Specified as a comma separated list of CSS selectors.
        */
       ieExcludedLinks: ["a.ignore"],

       /**
         * The blockedElements entry specifies a set of elements for
         * which no user interaction is to be reported. No user interaction
         * will be reported for the specified element and any child elements.
         * Elements can be specified as a comma separated list of CSS selectors.
         *
         * Warning: The blockedElements entry is evaluated for each event.
         * Specifying inefficient CSS selectors can cause performance issues.
         *
         * Note: This is an advanced feature which has implications for
         * Tealeaf functionality and must only be used in unique situations
         * that require such a restriction.
         *
         */
       blockedElements: [],

       /**
        * This is the module configuration section contains options 
        * relevant to the core.
        * It contains the events to which the modules attempt to listen.
        * NOTE: Please do not use this section for module-specific
        * configuration, which you must access inside of your modules.
        * @type {Object}
        */
       modules: {
           performance: {
               enabled: true,
               events: [
                   {
                       name: "load",
                       target: window
                   },
                   {
                       name: "unload",
                       target: window
                   }
               ]
           },
           replay: {
               enabled: true,
               events: [
                   /* Lifecycle events - not optional */
                   {
                       name: "load",
                       target: window
                   },
                   {
                       name: "unload",
                       target: window
                   },
                   /* User interaction events - not optional */
                   {
                       name: "change",
                       target: changeTarget,
                       recurseFrames: true
                   },
                   {
                       name: "click",
                       recurseFrames: true
                   },

                   /* Dwell time and previous state */
                   {
                       name: "focus",
                       target: "input, select, textarea, [contenteditable]",
                       recurseFrames: true
                   },
                   {
                       name: "blur",
                       target: "input, select, textarea, [contenteditable]",
                       recurseFrames: true
                   },

                   /* Hash change - optional */
                   {
                     name: "hashchange",
                     target: window
                   },

                   /* ClientState events - not optional */
                   {
                       name: "resize",
                       target: window
                   },
                   {
                       name: "scroll",
                       target: window
                   },

                   /* Mobile DOM events - optional */
                   {
                       name: "orientationchange",
                       target: window
                   },
                   {
                       name: "touchend"
                   },
                   { 
                       name: "visibilitychange"
                   }
               ]
           }
       }
   },
},
/* Following settings are related to the TLT.getSessionData() Public API */

/**
* Set the sessionDataEnabled flag to true only if it is OK to expose Tealeaf
* session data to 3rd party scripts.
*/
sessionDataEnabled: false,

/**
* The sessionData object specifies the query parameter name OR cookie name to
* get the session id value from. An actual deployment would only specify one
* of the methods to obtain the session id. If both are specified, the
* sessionQueryName takes precedence over sessionCookieName. If neither is
* specified, an internal default of "TLTSID" will be looked up in the cookies.
*/
sessionData: {
    /**
    * Specify sessionQueryName only if the session id is derived from a
    * query parameter.
    */
    sessionQueryName: "sessionID",

    /* Optionally, specify the query string delimiter. Default is */
    sessionQueryDelim: ";",

    /* The cookie being used for sessionization in Tealeaf. */
    sessionCookieName: "jsessionid",

    /**
    * Optionally, specify if the value needs to be hashed to derive the
    * session ID.
    */
    sessionValueNeedsHashing: true
}
   /**
    * The framesBlacklist array specifies the CSS selectors which correspond to the
    * frame/iframe elements that should not be accessed.
    */
framesBlacklist: [
    ".tlBlock"
]
},

   /* End of core configuration */

   // Services configuration

   ...

   // Module specific configuration

   ...

});

ieExcludedLinks: ["a[href^=javascript]", "a.ignore"],

blockedUserAgents: [{
        regex: "(Google|Bing|Face|DuckDuck|Yandex|Exa)bot",
        flags: "i"
    },
    {
        regex: "spider",
        flags: "i"
    },
    {
        regex: "archiver",
        flags: "i"
    },
    "PhantomJS"
],

core: {
    ....
    screenviewLoadEvent: {         
        name: "click",   //This could be any custom event, or DOM event.      
        target: window         
    }
    ....
}

{
                       name: "load",
                       target: window
                   },

{
                       name: "click",
                       recurseFrames: true
                   },

services: {
    queue: {
        // WARNING: Enabling asynchronous request on unload may result in incomplete or missing data
        asyncReqOnUnload: false,
        queues: [{
                qid: "DEFAULT",
                endpoint: "/TealeafTarget.php",
                maxEvents: 50,
                timerInterval: 300000,
                maxSize: 300000
            }
        ]
    },
    message: {
        privacy: [{
                targets: [
                    // CSS Selector: All password input fields
                    "input[type=password]"
                ],
                "maskType": 3
            }
        ]
    },
    serializer: {
        json: {
            defaultToBuiltin: true,
            parsers: ["JSON.parse"],
            stringifiers: ["JSON.stringify"]
        }
    },
    encoder: {
        gzip: {
            /**
             * The encode function should return encoded data in an object like this:
             * {
             *     buffer: "encoded data"
             * }
             */
            encode: "window.pako.gzip",
            defaultEncoding: "gzip"
        }
    },
    domCapture: {
        diffEnabled: true
    },
    browser: {
        normalizeTargetToParentLink: true
    }
}

message: {
    /**
     * Applications using Shadow DOM should enable this setting.
     */
    shadowDOMCacheEnabled: true,

    /**
     * Define privacy rules to modify/mask reported values in the
     * messages sent to the server.
     * @type {Array}
     * @optional
     */
    privacy: [
        /**
         * An example privacy rule.
         */
        {
            /**
             * Specify the targets to which this rule should apply.
             * @type {Array}
             */
            targets: [
                {
                    id: "htmlid",
                    idType: -1
                },
                {
                    id: "myid=custom",
                    idType: -3
                }
            ],
            /**
             * The maskType defines how the value should get
             * transformed.
             * maskType 1: The value gets set to an empty string
             * maskType 2: The value gets replaced with the fixed
             *             string "XXXXX".
             * maskType 3: The value gets replaced by a mask where:
             *     each lowercase character gets replaced by "x",
             *     each uppercase character by "X",
             *     each number by "9"
             *     each symbol by "@"
             *     e.g. "HelloWorld123" becomes "XxxxxXxxxx999"
             * maskType 4: The value gets replaced by the return
             *             value from the custom function that is
             *             specified as maskFunction.
             * @type {Number}
             */
            maskType: 3
        }, 
        /**
         * another example of a privacy rule.
         */
        {
            targets: [
                {
                    id: "[[\"html\",0],[\"body\",0],[\"input\",0]]",
                    idType: -2
                }
            ],
            maskType: 4,
            /**
             * A custom mask function that replaces the value
             * with its return value ("masked", in this example)
             * @param  {String} value The value to replace.
             * @return {String} Can return any string.
             */
            maskFunction: function (value) {
                return "masked";
            }
        }
    ]
}

{
                   targets: [
                       {
                           id: "htmlid",
                           idType: -1
                       }
                   ],
                   maskType: 3
               }

message: {
    privacy: [
        {
            targets: [
                "input[type=password]"
            ],
            "maskType": 3
        }
    ]
}

serializer: {
                json: {
                    defaultToBuiltin: true,
                    parsers: [ "JSON.parse" ],
                    stringifiers: [ "JSON.stringify" ]
                }
            },
            encoder: {
                gzip: {
                    /**
                     * The encode function should return encoded data in an object like this:
                     * {
                     *     buffer: "encoded data"
                     * }
                     */
                    encode: "window.pako.gzip",
                    defaultEncoding: "gzip"
                }
            },
            domCapture: {
                diffsEnabled: true
            },
            browser: {
                normalizeTargetToParentLink: true
            }
        },

domCapture: {
                diffEnabled: true
            }

domCapture: {
                diffEnabled: true,
                options: {
                    maxMutations: 500,
                    captureFrames: true
                }
            }

browser: {
           /**
            * useCapture is a boolean flag to indicate if the event capture phase
            * should be used on browsers that support event capture.  This flag
            * is enabled by default.
            *
            * If disabled or the browser does not support event capture then
            * event bubbling will be used. Event bubbling could cause some events
            * to be missed if the application is preventing them from bubbling.
            *
            * For additional details on event capture and bubbling refer to the
            * W3C DOM specification at:
            *  http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-flow
            * @type {Boolean}
            */
            useCapture: true,

           /**
            * To specify elements whose HTML ids cannot be used as identifiers
            * or in xPath generation. Could be a string object with one or two
            * properties, "regex" (mandatory) and "flags". These are specified
            * as strings. The regex that is evaluated against the node id.
            * @type {Array}
            * @optional
            */
           blacklist: [
        "duplicateid", {
            regex: "/password|pass|pin|tan/",
            flags: "gi"
        }
    ],

    /**
     * If the application uses custom attributes as an ID replacement,
     * you may specify the attribute name here.
     * @type {Array}
     * @optional
     */
    customid: ["name", "custom-attribute"],

    normalizeTargetToParentLink: true,

    logAttributes: [
        "attr1",
        "attr2",
        "attr3",
        "attr4",
        "attr5",
    ]
},

overstat: {
                hoverThreshold: 1000
          },

modules: {
        performance: {
            calculateRenderTime: true,
            renderTimeThreshold: 600000,
        },

modules: {
	performance: {
		performanceAlert: {
		    /* required
		     * boolean
		     */
		    enabled: true,

   	            /* optional
		     * measured in ms
		     * capture the data if resources loading time exceeds threshold
		     */
		    threshold:3000,
                    
                     /* optional
		     * an integer number
		     * set the maximum number of alerts to be logged
		     */
		    maxAlerts: 400,


                    /* optional
		     * array of strings
		     * specify the resource type to monitor, monitor all resources by default
		     * possible values are "script", "link", "img", "xmlhttprequest", "iframe", etc
		     */
		    resourceTypes: ["script", "img"],

		    /* optional
		     * array of a string or regex object
		     * used to blacklist certain resources by matching the resource name (url)
		     */
		    blacklist: [{regex: "collector"}, {regex: "tealeaf"}, {regex: "tlt-worker"}, {regex: "bam\\.nr"}]
  		}
		...
	}
	...
}

replay: {
                
                // DOM Capture configuration
                domCapture: {
                    /**
                     * NOTE: Enabling DOM Capture has significant implications
                     * on data transmission and infrastructure.
                     * Hence this feature should be enabled judiciously. If
                     * enabled, it requires further configuration
                     * to only perform the DOM Capture based on specific events and 
                     * elements. Please refer to the
                     * documentation for more details.
                     */
                    enabled: false,
                    /**
                     * The rules for triggering DOM Snapshots are similar to the
                     * Privacy configuration.
                     * It accepts a mandatory "event" followed by one or more 
                     * optional targets
                     * as well as an optional delay after which to take the 
                     * DOM snapshot.
                     * 
                     * The default configuration below will capture a full DOM 
                     * snapshot for each and every click, change
                     * action as well as for all screenview load and unloads. 
                     * Please refer to the documentation for
                     * details on fine tuning this configuration to specific 
                     * elements and screenviews.
                     */
                    triggers: [
                        {
                            event: "click"
                        },
                        {
                            event: "change"
                        },
                        {
                            { event: "load", delayUntil: { selector: ".page-picker-spinner", exists: false, timeout:10000 }, fullDOMCapture:true}
                        }
                    ],
                }
            }

replay: {
    domCapture: {
        enabled: true,

        screenviewBlacklist:[
            "/some/url",
            {
                regex: "somerRegEx",  //JS Regex pattern
                flags: "someFlag"         //Optional JS Regex flags
            }, ...
        ],

        triggers: [{
            event: "load"
          }, ...
        ]
    }
}

TLCookie: {

    /**
     * Comma separated whitelist of cookie names (strings) or regular
     * expressions (objects). The specified application cookies will
     * be recorded on each screenview load. No application cookies
     * will be recorded if this list is undefined or empty.
     */
    appCookieWhitelist: [{
            regex: ".*"
        }

    ],

    /**
     * Copy and paste the TL SaaS application key.
     */
    tlAppKey: ""
}

TLCookie: {
    secureTLTSID: true,
    ...
}

TLCookie: {
    secureTLTSID: true,
    samesite: "None",
    ...
}

modules: {
  ...
  TLCookie: {
      // Parameterize
      appCookieWhitelist: [{ regex: ".*" }],
      tlAppKey: "",
      disableTLTDID: false
  }
  ...
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = 'gtm.dom'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: ['gtm.uniqueEventId'],
	      	propertyBlocklist: ['event'],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = 'gtm.dom'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: ['event'],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = 'gtm.dom'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: ['home','expo'],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = 'gtm.dom'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = 'gtm.dom'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

[
	{event: 'gtm.dom', gtm.uniqueEventId: 17},
	{0: 'set', 1: 'url_passthrough', 2: false},
	{"0":"set","1":{"user_id":"","page_path":"","page_title":"","page_location":"https://fakestore.com/us/cart"}},
	{"0":"event",
	 "1":"view_cart",
	 "2":{"page_title":"SHOPPING CART|CART",
	      "page_type":"SHOPPING CART",
	      "market":"US",
	      "version_info":"global|tenv.prod|ut4.49.202308021007|glass|DF0FD2B",
	      "url":"https://fakestore.com/us/cart",
	      "pathname":"/us/cart",
	      "page_owner":"ECOM",
	      "send_to":["G-4DGGV4HV95"],
	      "currency":"USD",
	      "items":[
	      	{"item_id":"IF72873488",
	      	 "item_name":"DAILY MY SHOES",
	      	 "item_brand":"ESSEN",
	      	 "item_category":"SHOES",
	      	 "item_variant":"IF72873488_640",
	      	 "price":"65.00",
	      	 "currency":"USD",
	      	 "quantity":"8"},
	      	{"item_id":"ID462800451",
	      	 "item_name":"GAZZZ",
	      	 "item_brand":"Y",
	      	 "item_category":"SHOES",
	      	 "item_variant":"ID462800451_650",
	      	 "price":"330.00",
	      	 "currency":"USD",
	      	 "quantity":"8"},
	      	]
	      }
	}
]

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = 'gtm.dom'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event',
	        		matchValue = /gtm/
	        	}
	        ]
	      }
	    }
	  ],
	}
}

{"0":"event",
 "1":"view_cart",
 "2":{"page_title":"SHOPPING CART|CART",
      "page_type":"SHOPPING CART",
      "market":"US",
      "version_info":"global|tenv.prod|ut4.49.202308021007|glass|DF0FD2B",
      "url":"https://fakestore.com/us/cart",
      "pathname":"/us/cart",
      "page_owner":"ECOM",
      "send_to":["G-4DGGV4HV95"],
      "currency":"USD",
      "items":[
      	{"item_id":"IF72873488",
      	 "item_name":"DAILY MY SHOES",
      	 "item_brand":"ESSEN",
      	 "item_category":"SHOES",
      	 "item_variant":"IF72873488_640",
      	 "price":"65.00",
      	 "currency":"USD",
      	 "quantity":"8"},
      	{"item_id":"ID462800451",
      	 "item_name":"GAZZZ",
      	 "item_brand":"Y",
      	 "item_category":"SHOES",
      	 "item_variant":"ID462800451_650",
      	 "price":"330.00",
      	 "currency":"USD",
      	 "quantity":"8"},
      	]
      }
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event'
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: /eve/
	        	}
	        ]
	      }
	    }
	  ],
	}
}

modules: {
	dataLayer: {
	  dataObjects: [
	    {
	      dataObject: "window.dataLayer",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	        filter: [
	        	{
	        		matchProperty: 'event'
	        	},
	        	{
	        		matchProperty: 'set'
	        	},
	        ]
	      }
	    },
	    {
	      dataObject: "window.utag",
	      rules: {
	      	includeEverything: true,
	      	permittedProperties: [],
	      	propertyBlocklist: [],
	        screenviewBlocklist: [],
	      }
	    }
	  ],
	}
}