Module

A module used by the Tealium SDK to provide some plugin functionality.

See more

public protocol Module : AnyObject

A restricted Module that can be created with some default parameters and only allows a single instance.

See more

public protocol BasicModule : Module

A basic factory that can be reused to create modules that have no extra dependencies and can only be initialized once.

BasicModuleFactory is a generic implementation of ModuleFactory that simplifies the creation of modules conforming to the BasicModule protocol.

For detailed guidance on creating custom modules, see Creating Custom Modules.

Important Notes

• The generic Module type must conform to BasicModule
• Modules created by this factory cannot be instantiated multiple times (allowsMultipleInstances is always false)
• Use ModuleSettingsBuilder subclasses for type-safe configuration
• Module type constants should be defined in Modules.Types for consistency

See more

public class BasicModuleFactory<Module> : ModuleFactory where Module : BasicModule

An error caused when trying to use a Module.

See more

public enum ModuleError<SomeError> : ErrorEnum, ErrorWrapping where SomeError : Error

A factory that is used to create a specific Module with some standard parameters.

See more

public protocol ModuleFactory

A ModuleProxy is to be used for proxying access to modules that are or were available to access from the main Tealium implementation.

Any external Module implementation that provides functionality expected to be used by a developer should wrap their access to Tealium through a ModuleProxy.

See more

public class ModuleProxy<SpecificModule, Failure> where SpecificModule : Module, Failure : Error

A base class that adds the enabled setter for SettingsBuilders that are Optional and therefore can be disabled.

See more

open class ModuleSettingsBuilder

A class responsible for registering and returning the DataStore instances required by individual modules.

See more

public class ModuleStoreProvider

Manages the lifecycle and configuration of modules within the Tealium SDK.

See more

public class ModulesManager

A settings builder for a module that supports multiple instances.

See more

public protocol MultipleInstancesModuleSettingsBuilder

A Module that implements the functionality of collecting data to enrich the data layer of each track request.

See more

public protocol Collector : Module

A builder for Collector Settings which adds the possibility to set Rules.

open class CollectorSettingsBuilder : ModuleSettingsBuilder, RuleModuleSettingsBuilder

Base class for command-based dispatchers that route dispatches through an internal command registry.

Provides a concrete implementation for dispatch() that supports async commands with cancellation via Disposable, calling completion once per Dispatch as it finishes.

Usage

class MyVendorDispatcher: CommandDispatcher {
    private let vendorInstance: VendorInterface

    init(context: TealiumContext, vendorInstance: VendorInterface) {
        self.vendorInstance = vendorInstance
        super.init(
            id: "MyVendor",
            version: "1.0.0",
            commands: [...],
            logCategory: "MyVendor",
            queue: context.queue,
            logger: context.logger
        )
    }
}

See more

open class CommandDispatcher : Dispatcher

A Module that implements the functionality of dispatching some track requests towards some entity that can handle the events.

See more

public protocol Dispatcher : Module

A builder for Dispatcher Settings which adds the possibility to set Rules and JSONOperation<MappingParameters>.

See more

open class DispatcherSettingsBuilder<M> : ModuleSettingsBuilder, RuleModuleSettingsBuilder where M : Mappings

Provides context and dependencies for modules within the Tealium SDK.

See more

public class TealiumContext

Generic reusable base class for building vendor-specific mappings.

Subclasses Mappings and adds overloaded methods that accept type-safe Command and Destination enums instead of raw strings.

Base Mappings methods (accepting String and JSONObjectPath) remain available for cases not covered by the enums.

See more

open class CommandMappingsBuilder<
    Command: CommandName,
    Destination: JSONObjectPathConvertible
>: Mappings

The Mappings builder is used to build up key/destination mappings used when optionally translating the full Dispatch payload to just the relevant data for any given Dispatcher.

Use the mapFrom method to supply the required source “key” and “destination” key, as well as any optional “path” entries required to access keys in nested object.

Using the following payload DataObject as an example (shown as JSON)

 {
      "source" : "value",
      "path": {
          "to" : [{
              "source": "nested value",
          }]
      }
 }

Simple usage for keys in the top level DataObject would look like so:

 mappings.mapFrom("source", to: "destination")

More complex versions requiring accessing keys that exist in nested objects and arrays would look like so:

 mappings.mapFrom(JSONPath["path"]["to"][0]["source"],
                  to: JSONPath["path"]["to"]["destination"])

Use the keep utility method to create a mapping where the source key is the same as the destination.

Simple usage for keys in the top level DataObject would look like so:

 mappings.keep("source")

More complex versions requiring accessing keys that exist in nested objects would look like so:

 mappings.keep(JSONPath["path"]["to"][0]["source"])

The mapFrom and keep methods return a VariableOptions that allows for setting optional properties relevant to a mapping like a ifValueEquals(:), to only perform the mapping if the value is equal to some specific string.

Use the mapConstant method to supply a constant “value” and “destination” key.

 mappings.mapConstant("value", to: "destination")

More complex versions requiring accessing keys that exist in nested objects would look like so:

 mappings.mapConstant(value, to: JSONPath["path"]["to"]["destination"])

The mapConstant method returns a ConstantOptions that allows for setting optional properties relevant to a mapping like a ifValueIn(:equals:), to only perform the mapping if a value at the given key is equal to the given target.

See more

open class Mappings

Base builder class for a single mapping operation. Use Mappings factory methods to create instances.

public class MappingsBuilder