### Session Replay Configuration Example (iOS)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Demonstrates how to configure the SessionReplayPlugin for session replay functionality on iOS. It shows the setup and how to access the session replay instance.

```swift
let sessionReplayConfig = SessionReplayPlugin.Config()
// Configure session replay settings

let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    sessionReplayConfig: sessionReplayConfig
)

// Access session replay
if let sessionReplay = amplitude.sessionReplay {
    // Session replay is configured
}
```

--------------------------------

### Plan Configuration Example

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Demonstrates how to configure plan versioning for events. Plans help in tracking and debugging different versions of events.

```swift
public struct Plan {
    public let version: String?
    public let branch: String?
}

let plan = Plan(version: "1.0", branch: "production")
let config = AnalyticsConfig(plan: plan)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### Minimal Amplitude Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Use this for the simplest setup. The SDK initializes with default configurations and registers necessary plugins.

```swift
import AmplitudeUnified

let amplitude = Amplitude(apiKey: "YOUR_API_KEY")

// Ready to use
amplitude.track(eventType: "App Started")
```

--------------------------------

### Experiment Configuration Example

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Shows how to configure and use the ExperimentPlugin for feature flagging. It includes setting up the experiment configuration and accessing the experiment client to retrieve variants.

```swift
let experimentConfig = ExperimentPlugin.Config()
// Configure experiment settings

let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    experimentConfig: experimentConfig
)

// Access experiment client
if let experimentClient = amplitude.experiment {
    let variant = experimentClient.variant(flag: "feature_flag_key")
}
```

--------------------------------

### Initialize ObjCAmplitude with API Key

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Use this initializer for a basic setup with only the API key. It defaults to the standard server zone and a nil logger.

```objc
ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] initWithApiKey:@"YOUR_API_KEY"];
[amplitude track:@"Button Clicked" withProperties:nil];
```

--------------------------------

### Simple Objective-C Amplitude Setup

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Initialize Amplitude in Objective-C using a singleton pattern for easy access throughout the application. This setup is suitable for basic tracking needs.

```objc
#import <AmplitudeUnified/AmplitudeUnified-Swift.h>

@implementation AppDelegate

+ (ObjCAmplitude *)amplitude {
    static ObjCAmplitude *instance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[ObjCAmplitude alloc] initWithApiKey:@"YOUR_API_KEY"];
    });
    return instance;
}

- (BOOL)application:(UIApplication *)application 
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [AppDelegate.amplitude track:@"App Launched"];
    return YES;
}

```

--------------------------------

### Initialize Amplitude SDK in Swift

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/quick-start.md

Initialize the Amplitude SDK with your API key. This is the basic setup required for all SDK functionalities.

```swift
import AmplitudeUnified

let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
```

--------------------------------

### Track Events After Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/amplitude-initializer.md

Example of tracking an event after the Amplitude SDK has been initialized.

```swift
amplitude.track(eventType: "Button Clicked")
```

--------------------------------

### Multi-Instance Management Example

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Shows how to manage multiple Amplitude instances for separate analytics pipelines, such as for production and development environments. Each instance maintains its own queues and configuration.

```swift
// Production instance
let productionAmplitude = Amplitude(
    apiKey: "PROD_KEY",
    instanceName: "production"
)

// Development instance
let devAmplitude = Amplitude(
    apiKey: "DEV_KEY",
    instanceName: "development"
)

// Each maintains separate queues, sessions, and configuration
productionAmplitude.track(eventType: "Production Event")
devAmplitude.track(eventType: "Dev Event")
```

--------------------------------

### Default Analytics Configuration

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/analytics-configuration.md

Initialize the Amplitude SDK with default configuration settings. This is the simplest way to start.

```swift
let config = AnalyticsConfig()
let amplitude = Amplitude(apiKey: "YOUR_API_KEY", analyticsConfig: config)
```

--------------------------------

### Tracking Options Customization Example

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Illustrates how to customize tracking options to control which default properties are automatically tracked by the SDK.

```swift
var trackingOptions = TrackingOptions()
// Configure which properties to track
// (implementation depends on AmplitudeSwift)

let config = AnalyticsConfig(trackingOptions: trackingOptions)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### Configure Enterprise Setup

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/configuration-reference.md

Set up Amplitude for enterprise use by specifying a custom server URL, providing a specific storage provider like KeychainStorage, configuring maximum retries for event flushing, and defining the plan details.

```swift
let config = AnalyticsConfig(
    serverURL: "https://amplitude.internal.company.com",
    storageProvider: KeychainStorage(),
    flushMaxRetries: 10,
    plan: Plan(version: "1.0", branch: "production")
)
```

--------------------------------

### Testing UnifiedSDKPlugin Behavior

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/unified-sdk-plugin.md

Provides a code example used in tests to verify the behavior of the UnifiedSDKPlugin. It initializes the SDK, tracks an event, and shows the expected format of the 'library' field after plugin processing.

```swift
let amplitude = Amplitude(apiKey: "",
                          analyticsConfig: .init(autocapture: [],
                                                 enableAutoCaptureRemoteConfig: false))
amplitude.track(eventType: "Test")

// Event library after plugin processing:
// "amplitude-swift-unified/0.0.3-Amplitude-Swift/1.17.0"
```

--------------------------------

### AnalyticsConfig Constructor

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/analytics-configuration.md

Initializes the Amplitude SDK with a comprehensive set of configuration options. All parameters have sensible defaults, allowing for easy setup or fine-grained control over SDK behavior.

```APIDOC
## init

### Description
Initializes the Amplitude SDK with a comprehensive set of configuration options. All parameters have sensible defaults, allowing for easy setup or fine-grained control over SDK behavior.

### Method
`init` (Constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **flushQueueSize** (Int) - No - `Configuration.Defaults.flushQueueSize` - Number of events to batch before flushing
* **flushIntervalMillis** (Int) - No - `Configuration.Defaults.flushIntervalMillis` - Milliseconds between automatic flushes
* **storageProvider** ((any Storage)?) - No - `nil` - Custom storage implementation for events
* **identifyStorageProvider** ((any Storage)?) - No - `nil` - Custom storage for identify events
* **minIDLength** (Int?) - No - `nil` - Minimum length for user ID validation
* **partnerID** (String?) - No - `nil` - Partner identifier for attribution
* **callback** (EventCallback?) - No - `nil` - Callback invoked when events are flushed
* **flushMaxRetries** (Int) - No - `Configuration.Defaults.flushMaxRetries` - Maximum retry attempts for failed flushes
* **useBatch** (Bool) - No - `Configuration.Defaults.useBatch` - Use batch API endpoint if true, default single endpoint if false
* **serverURL** (String?) - No - `nil` - Custom ingestion endpoint URL
* **plan** (Plan?) - No - `nil` - Plan object for event versioning
* **ingestionMetadata** (IngestionMetadata?) - No - `nil` - Metadata for ingestion pipeline configuration
* **trackingOptions** (TrackingOptions) - No - `Configuration.Defaults.trackingOptions` - Controls which default properties are tracked
* **enableCoppaControl** (Bool) - No - `Configuration.Defaults.enableCoppaControl` - Enable COPPA compliance mode
* **flushEventsOnClose** (Bool) - No - `Configuration.Defaults.flushEventsOnClose` - Flush all pending events when app closes
* **minTimeBetweenSessionsMillis** (Int) - No - `Configuration.Defaults.minTimeBetweenSessionsMillis` - Milliseconds before session times out
* **autocapture** (AutocaptureOptions) - No - `Configuration.Defaults.autocaptureOptions` - Autocapture feature settings
* **identifyBatchIntervalMillis** (Int) - No - `Configuration.Defaults.identifyBatchIntervalMillis` - Milliseconds between identify batches
* **maxQueuedEventCount** (Int) - No - `Configuration.Defaults.maxQueuedEventCount` - Maximum events to queue before forced flush
* **migrateLegacyData** (Bool) - No - `Configuration.Defaults.migrateLegacyData` - Migrate data from legacy SDK versions
* **enableAutoCaptureRemoteConfig** (Bool) - No - `Configuration.Defaults.enableAutoCaptureRemoteConfig` - Allow remote configuration of autocapture

### Request Example
```swift
AnalyticsConfig(
    flushQueueSize: 100,
    flushIntervalMillis: 5000,
    serverURL: "https://api.amplitude.com",
    trackingOptions: TrackingOptions(carrier: false, deviceManufacturer: false, deviceModel: false, language: false, osName: false, osVersion: false, platform: false, rampId: false, рекламныеId: false)
)
```

### Response
#### Success Response (200)
A fully configured `AnalyticsConfig` struct with all mutable properties set. All parameters have sensible defaults from `Configuration.Defaults`.

#### Response Example
```swift
AnalyticsConfig(
    flushQueueSize: 100,
    flushIntervalMillis: 5000,
    storageProvider: nil,
    identifyStorageProvider: nil,
    minIDLength: nil,
    partnerID: nil,
    callback: nil,
    flushMaxRetries: 3,
    useBatch: true,
    serverURL: "https://api.amplitude.com",
    plan: nil,
    ingestionMetadata: nil,
    trackingOptions: TrackingOptions(carrier: false, deviceManufacturer: false, deviceModel: false, language: false, osName: false, osVersion: false, platform: false, rampId: false, рекламныеId: false),
    enableCoppaControl: false,
    flushEventsOnClose: true,
    minTimeBetweenSessionsMillis: 60000,
    autocapture: AutocaptureOptions(),
    identifyBatchIntervalMillis: 1000,
    maxQueuedEventCount: 10000,
    migrateLegacyData: false,
    enableAutoCaptureRemoteConfig: true
)
```
```

--------------------------------

### Dynamic Server Zone Configuration

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Configure the Amplitude server zone dynamically based on user locale or other criteria. This example determines the zone based on the device's current region code.

```swift
func getServerZone() -> ServerZone {
    let locale = Locale.current
    if let countryCode = locale.regionCode,
       isEuropeanCountry(countryCode) {
        return .EU
    }
    return .US
}

let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    serverZone: getServerZone()
)
```

--------------------------------

### Lazy Initialization of Amplitude in Swift

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Implement lazy initialization for Amplitude in Swift to defer setup until it's first used. This pattern can improve application startup performance by delaying resource-intensive operations.

```swift
class AnalyticsManager {
    private var _amplitude: Amplitude?
    
    var amplitude: Amplitude {
        if _amplitude == nil {
            _amplitude = Amplitude(apiKey: "YOUR_API_KEY")
        }
        return _amplitude!
    }
    
    func track(eventType: String) {
        amplitude.track(eventType: eventType)
    }
}

// Initialization happens on first use
let manager = AnalyticsManager()
manager.track(eventType: "App Started")  // Initializes here
```

--------------------------------

### Basic Amplitude SDK Usage in Swift

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/README.md

Demonstrates initializing the SDK, tracking events, setting user properties with Identify, and setting the user ID.

```swift
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")

amplitude.track(eventType: "Button Clicked", eventProperties: ["button_id": "sign_up"])

let identify = Identify()
identify.set(property: "plan", value: "premium")
amplitude.identify(identify: identify)

amplitude.setUserId(userId: "user@example.com")
```

--------------------------------

### Destination Plugin Example

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Example of a custom destination plugin that aggregates events. This plugin increments an event count and can be extended to send events to multiple endpoints or apply transformations.

```swift
class AnalyticsAggregator: Plugin {
    let type: PluginType = .destination
    let name = "com.myapp.AnalyticsAggregator"
    
    var eventCount = 0
    
    func execute(event: BaseEvent) -> BaseEvent? {
        // Aggregate and forward events
        eventCount += 1
        
        // You could send to multiple endpoints here
        // or apply additional transformations
        
        return event
    }
}
```

--------------------------------

### Amplitude Initialization with All Configuration Options

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/amplitude-initializer.md

Initialize the Amplitude SDK with all available configuration options, including server zone, instance name, and specific plugin configurations.

```swift
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    serverZone: .US,
    instanceName: "main",
    analyticsConfig: AnalyticsConfig(),
    experimentConfig: ExperimentPlugin.Config(),
    sessionReplayConfig: SessionReplayPlugin.Config(),
    logger: ConsoleLogger()
)
```

--------------------------------

### ObjCAmplitude init(apiKey:serverZone:)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Initializes an ObjCAmplitude instance with a specified API key and server zone. The logger defaults to nil.

```APIDOC
## Constructor: init(apiKey:serverZone:)

### Description
Initializes an `ObjCAmplitude` instance with the provided API key and server zone. The logger defaults to nil.

### Method
`init(apiKey: String, serverZone: AmplitudeCore.ServerZone)`

### Parameters
#### Path Parameters
* **apiKey** (String) - Required - API key for Amplitude project
* **serverZone** (AmplitudeCore.ServerZone) - Required - Server region: `.US` or `.EU`

### Return Type
Initializes an `ObjCAmplitude` instance with the provided API key and server zone.

### Behavior
Creates an instance with specified server zone but defaults the logger to nil. Note: There is a known bug where it always uses `Configuration.Defaults.serverZone` instead of the passed `serverZone` parameter.

### Request Example
```objc
ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] initWithApiKey:@"YOUR_API_KEY" serverZone:AmplitudeCoreServerZoneUS];
```
```

--------------------------------

### Swift Initialization Flow

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/module-overview.md

Illustrates the step-by-step process for initializing the Amplitude SDK in Swift, including base class initialization and plugin additions.

```text
Amplitude(apiKey:...) → 
  init(configuration: ...) [base class] → 
  add(plugin: SessionReplayPlugin) → 
  add(plugin: ExperimentPlugin) → 
  add(plugin: UnifiedSDKPlugin) → 
  Ready for tracking
```

--------------------------------

### ObjCAmplitude init(apiKey:)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Initializes an ObjCAmplitude instance using only the API key. It defaults to the standard server zone and a nil logger, internally calling a more comprehensive initializer.

```APIDOC
## Constructor: init(apiKey:)

### Description
Initializes an `ObjCAmplitude` instance with the provided API key. This initializer uses default configurations for the server zone and logger.

### Method
`init(apiKey: String)`

### Parameters
#### Path Parameters
* **apiKey** (String) - Required - API key for Amplitude project

### Return Type
Initializes an `ObjCAmplitude` instance with the API key and default server zone (`Configuration.Defaults.serverZone`).

### Behavior
This initializer uses the default server zone, creates a nil logger (falling back to default), and internally calls `init(apiKey:logger:)` with logger=nil.

### Request Example
```objc
ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] initWithApiKey:@"YOUR_API_KEY"];
[amplitude track:@"Button Clicked" withProperties:nil];
```
```

--------------------------------

### Custom Plugin Registration in Swift

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Register a custom plugin with Amplitude in Swift to extend its functionality. This example shows how to add an `app_version` property to events before they are sent.

```swift
// Custom plugin
class VersionPlugin: Plugin {
    let type: PluginType = .before
    let name = "com.myapp.VersionPlugin"
    let appVersion: String
    
    init(appVersion: String) {
        self.appVersion = appVersion
    }
    
    func execute(event: BaseEvent) -> BaseEvent? {
        event.eventProperties?["app_version"] = appVersion
        return event
    }
}

// Registration
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
amplitude.add(plugin: VersionPlugin(appVersion: "1.0.0"))
```

--------------------------------

### Amplitude Initialization with Configuration

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initialize the Amplitude client with an API key and custom analytics configuration.

```swift
let config = AnalyticsConfig(
    flushQueueSize: 50,
    enableCoppaControl: true
)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### ObjCAmplitude init(apiKey:serverZone:instanceName:analyticsConfig:experimentConfig:sessionReplayConfig:logger:)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Initializes an ObjCAmplitude instance with comprehensive configuration options, including API key, server zone, instance name, analytics, experiment, session replay configurations, and an optional logger. This is iOS only when Session Replay is involved.

```APIDOC
## Constructor: init(apiKey:serverZone:instanceName:analyticsConfig:experimentConfig:sessionReplayConfig:logger:)

### Description
Initializes an `ObjCAmplitude` instance with a full suite of configuration options, including API key, server zone, instance name, analytics configuration, experiment configuration, session replay configuration, and a custom logger. This initializer is iOS-specific when Session Replay is included.

### Method
`init(
    apiKey: String,
    serverZone: AmplitudeCore.ServerZone = Configuration.Defaults.serverZone,
    instanceName: String = Configuration.Defaults.instanceName,
    analyticsConfig: ObjCAnalyticsConfig = .init(),
    experimentConfig: ExperimentPlugin.Config = .init(),
    sessionReplayConfig: SessionReplayPlugin.Config = .init(),
    logger: ObjCLoggerProvider? = nil
)`

### Parameters
#### Path Parameters
* **apiKey** (String) - Required - API key for Amplitude project
* **serverZone** (AmplitudeCore.ServerZone) - Optional - Default: `Configuration.Defaults.serverZone` - Server region: `.US` or `.EU`
* **instanceName** (String) - Optional - Default: `Configuration.Defaults.instanceName` - Named instance for multiple SDK instances
* **analyticsConfig** (ObjCAnalyticsConfig) - Optional - Default: `.init()` - Analytics configuration (Objective-C compatible)
* **experimentConfig** (ExperimentPlugin.Config) - Optional - Default: `.init()` - Experiment feature flag configuration
* **sessionReplayConfig** (SessionReplayPlugin.Config) - Optional - Default: `.init()` - Session Replay configuration
* **logger** (ObjCLoggerProvider?) - Optional - Default: `nil` - Custom Objective-C logger

### Return Type
Initializes an `ObjCAmplitude` instance with complete configuration including Session Replay (iOS only).

### Behavior
This initializer creates an `ObjCConfiguration` from the provided analytics parameters, initializes the base `ObjCAmplitude` instance, and then registers the `SessionReplayPlugin` (for iOS), `ExperimentPlugin`, and `UnifiedSDKPlugin`.

### Request Example
```objc
ObjCAnalyticsConfig *analyticsConfig = [[ObjCAnalyticsConfig alloc] init];
analyticsConfig.enableCoppaControl = YES;
analyticsConfig.flushQueueSize = 50;

ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] 
    initWithApiKey:@"YOUR_API_KEY"
    serverZone:AmplitudeCoreServerZoneUS
    instanceName:@"main"
    analyticsConfig:analyticsConfig
    experimentConfig:[[ExperimentPluginConfig alloc] init]
    sessionReplayConfig:[[SessionReplayPluginConfig alloc] init]
    logger:nil];
```
```

--------------------------------

### Initialize ObjCAmplitude Swift SDK (Minimal)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initialize the Objective-C compatible Amplitude SDK with only the required API key, using default configurations for other parameters.

```swift
public extension ObjCAmplitude {
    @objc convenience init(apiKey: String)
}
```

--------------------------------

### Configure Minimum Time Between Sessions

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/configuration-reference.md

Set the minimum duration in milliseconds that must pass between app backgrounding and foregrounding to start a new session. The default is 5 minutes (300000 ms).

```swift
let config = AnalyticsConfig(minTimeBetweenSessionsMillis: 600000)  // 10 minutes
```

--------------------------------

### Multi-Instance Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/architecture.md

Demonstrates how to initialize multiple independent instances of the Amplitude SDK, each with its own configuration and state.

```swift
let primary = Amplitude(
    apiKey: "KEY1",
    instanceName: "primary"
)

let secondary = Amplitude(
    apiKey: "KEY2",
    instanceName: "secondary"
)

// Each maintains separate:
// - Event queue
// - Session state
// - Configuration
```

--------------------------------

### Initialize ObjCAmplitude Swift SDK (Full Configuration - iOS)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initialize the Objective-C compatible Amplitude SDK on iOS with a full set of configurations, including API key, server zone, instance name, analytics, experiments, session replay, and logger.

```swift
@objc convenience init(
    apiKey: String,
    serverZone: AmplitudeCore.ServerZone = Configuration.Defaults.serverZone,
    instanceName: String = Configuration.Defaults.instanceName,
    analyticsConfig: ObjCAnalyticsConfig = .init(),
    experimentConfig: ExperimentPlugin.Config = .init(),
    sessionReplayConfig: SessionReplayPlugin.Config = .init(),
    logger: ObjCLoggerProvider? = nil
)
```

--------------------------------

### Initialize Amplitude SDK in Swift

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/START_HERE.md

Basic initialization of the Amplitude SDK using an API key. Tracks a simple button click event.

```swift
import AmplitudeUnified
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
amplitude.track(eventType: "Button Clicked")
```

--------------------------------

### Initialize ObjCAmplitude Swift SDK (Server Zone)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initialize the Objective-C compatible Amplitude SDK with an API key and a specified server zone. Note: A bug may cause it to ignore the provided server zone and use default values.

```swift
@objc convenience init(apiKey: String, serverZone: AmplitudeCore.ServerZone)
```

--------------------------------

### Full ObjCAmplitude Initialization with Plugins (iOS)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

This comprehensive initializer is for iOS and includes configuration for analytics, experiments, session replay, and a custom logger. It registers several core plugins.

```objc
ObjCAnalyticsConfig *analyticsConfig = [[ObjCAnalyticsConfig alloc] init];
analyticsConfig.enableCoppaControl = YES;
analyticsConfig.flushQueueSize = 50;

ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] 
    initWithApiKey:@"YOUR_API_KEY"
    serverZone:AmplitudeCoreServerZoneUS
    instanceName:@"main"
    analyticsConfig:analyticsConfig
    experimentConfig:[[ExperimentPluginConfig alloc] init]
    sessionReplayConfig:[[SessionReplayPluginConfig alloc] init]
    logger:nil];
```

--------------------------------

### Basic Amplitude Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/amplitude-initializer.md

Initialize the Amplitude SDK with only the required API key.

```swift
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
```

--------------------------------

### Objective-C Initialization for AmplitudeUnified

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/module-overview.md

Offers Objective-C compatible initializers for ObjCAmplitude, facilitating interoperation. Includes convenience initializers and accessor properties for Experiment and SessionReplay.

```objectivec
public extension ObjCAmplitude {
    @objc convenience init(apiKey: String)
    @objc convenience init(apiKey: String, serverZone: AmplitudeCore.ServerZone)
    @objc convenience init(
        apiKey: String,
        serverZone: AmplitudeCore.ServerZone = ...,
        instanceName: String = ...,
        analyticsConfig: ObjCAnalyticsConfig = .init(),
        experimentConfig: ExperimentPlugin.Config = .init(),
        sessionReplayConfig: SessionReplayPlugin.Config = .init(),
        logger: ObjCLoggerProvider? = nil
    )
}
```

--------------------------------

### Configure Experiment Plugin

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/configuration-reference.md

Initialize the Amplitude SDK with configuration for the Experiment plugin, which provides feature flag capabilities. The default config allows basic functionality.

```swift
let experimentConfig = ExperimentPlugin.Config()
// (Configuration structure depends on Experiment SDK)

let amplitude = Amplitude(
    apiKey: "KEY",
    experimentConfig: experimentConfig
)
```

--------------------------------

### Initialize ObjCAmplitude with API Key and Server Zone

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Initialize the SDK with a specific server zone. Note: A known bug may cause this initializer to ignore the provided server zone and use the default instead.

```objc
ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] initWithApiKey:@"YOUR_API_KEY"
                                                        serverZone:AmplitudeCoreServerZoneUS];
```

--------------------------------

### Initialize Amplitude SDK in Objective-C

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/START_HERE.md

Basic initialization of the Amplitude SDK for Objective-C projects using an API key. Tracks a simple event with no properties.

```objc
#import <AmplitudeUnified/AmplitudeUnified-Swift.h>
ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] initWithApiKey:@"YOUR_API_KEY"];
[amplitude track:@"Button Clicked" withProperties:nil];
```

--------------------------------

### Swift Configuration Path

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/architecture.md

Illustrates the configuration flow when using Swift structs for analytics configuration.

```swift
AnalyticsConfig (Swift struct)
    ↓
    │ (Unified initializer converts)
    ↓
Configuration (AmplitudeSwift internal)
    ↓
    │ (Used by AmplitudeSwift)
    ↓
Amplitude instance configured
```

--------------------------------

### Amplitude Initialization with EU Server Zone

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/amplitude-initializer.md

Initialize the Amplitude SDK specifying the EU server zone.

```swift
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    serverZone: .EU
)
```

--------------------------------

### Amplitude Swift Constructor

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/amplitude-initializer.md

Initializes the Amplitude SDK with various configuration options. Use this for setting up analytics, experiments, and session replay.

```swift
convenience init(
    apiKey: String,
    serverZone: AmplitudeCore.ServerZone = .US,
    instanceName: String = Constants.Configuration.DEFAULT_INSTANCE,
    analyticsConfig: AnalyticsConfig = .init(),
    experimentConfig: ExperimentPlugin.Config = .init(),
    sessionReplayConfig: SessionReplayPlugin.Config = .init(),
    logger: any Logger = ConsoleLogger()
)
```

--------------------------------

### Objective-C Initialization Flow

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/module-overview.md

Details the initialization sequence for the Amplitude SDK when used from Objective-C, covering base configuration and plugin registration.

```text
ObjCAmplitude(apiKey:...) → 
  init(configuration: ObjCConfiguration) [base class] → 
  add(plugin: SessionReplayPlugin) → 
  add(plugin: ExperimentPlugin) → 
  add(plugin: UnifiedSDKPlugin) → 
  Ready for tracking
```

--------------------------------

### Swift SDK Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/README.md

Initialize the Amplitude Unified SDK with your API key in Swift. This is the primary entry point for using the SDK.

```swift
import AmplitudeUnified
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
```

--------------------------------

### Autocapture Options Configuration

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Demonstrates how to configure autocapture options to enable automatic event capture for user interactions like sessions and clicks, and how to allow remote configuration.

```swift
let config = AnalyticsConfig(
    autocapture: [.sessions, .clicks],  // Enable specific autocapture
    enableAutoCaptureRemoteConfig: true  // Allow remote configuration
)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### Initialize Amplitude for iOS (Session Replay)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/quick-start.md

Initialize the Amplitude SDK on iOS. Session Replay is automatically available and configured.

```swift
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
// sessionReplayConfig is automatically registered
```

--------------------------------

### Objective-C Configuration Path

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/architecture.md

Illustrates the configuration flow when using Objective-C classes for analytics configuration.

```objectivec
ObjCAnalyticsConfig (Objective-C class)
    ↓
    │ (Unified initializer converts)
    ↓
ObjCConfiguration (AmplitudeSwift internal)
    ↓
    │ (Used by AmplitudeSwift)
    ↓
ObjCAmplitude instance configured
```

--------------------------------

### ObjCAmplitude Class Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initializes the ObjCAmplitude SDK for Objective-C compatibility with various configurations tailored for different platforms.

```APIDOC
## ObjCAmplitude Class (Extended)

**Module:** `AmplitudeUnified`
**Base:** `ObjCAmplitude` from `AmplitudeSwift`
**Objective-C Name:** `AMPAmplitude`

### Minimal Initialization

```swift
public extension ObjCAmplitude {
    @objc convenience init(apiKey: String)
}
```

**Parameters:**
- `apiKey: String` — Required. Amplitude API key

**Use Case:** Simple initialization with defaults

### Server Zone Initialization

```swift
@objc convenience init(apiKey: String, serverZone: AmplitudeCore.ServerZone)
```

**Parameters:**
- `apiKey: String` — Required. Amplitude API key
- `serverZone: AmplitudeCore.ServerZone` — Required. Server region

**Note:** Bug present: always uses `Configuration.Defaults.serverZone` instead of parameter value

### Full Configuration (iOS)

```swift
@objc convenience init(
    apiKey: String,
    serverZone: AmplitudeCore.ServerZone = Configuration.Defaults.serverZone,
    instanceName: String = Configuration.Defaults.instanceName,
    analyticsConfig: ObjCAnalyticsConfig = .init(),
    experimentConfig: ExperimentPlugin.Config = .init(),
    sessionReplayConfig: SessionReplayPlugin.Config = .init(),
    logger: ObjCLoggerProvider? = nil
)
```

**Platform:** iOS only (with Session Replay)

### Full Configuration (Non-iOS)

```swift
@objc convenience init(
    apiKey: String,
    serverZone: AmplitudeCore.ServerZone = Configuration.Defaults.serverZone,
    instanceName: String = Configuration.Defaults.instanceName,
    analyticsConfig: ObjCAnalyticsConfig = .init(),
    experimentConfig: ExperimentPlugin.Config = .init(),
    logger: ObjCLoggerProvider? = nil
)
```

**Platform:** tvOS, macOS, watchOS, visionOS (without Session Replay)

### Plugin Access Properties

```swift
@objc var experiment: ExperimentClient? {
    return (self as? PluginHost)?.experiment
}

@objc var sessionReplay: SessionReplay? {  // iOS only
    return (self as? PluginHost)?.sessionReplay
}
```

**Type:** Properties
**Return Type:** Optional plugin instances
```

--------------------------------

### Amplitude Initialization with Custom Analytics Configuration

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/amplitude-initializer.md

Initialize the Amplitude SDK with a custom analytics configuration, such as flush queue size and interval.

```swift
let analyticsConfig = AnalyticsConfig(
    flushQueueSize: 100,
    flushIntervalMillis: 30000,
    enableCoppaControl: true
)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: analyticsConfig
)
```

--------------------------------

### Add Amplitude Unified SDK via Swift Package Manager

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/README.md

Instructions for adding the SDK using Xcode's Swift Package Manager.

```text
https://github.com/amplitude/AmplitudeUnified-Swift
```

--------------------------------

### Initialize ObjCAnalyticsConfig and Amplitude

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-analytics-config.md

Instantiate ObjCAnalyticsConfig with custom properties and then initialize Amplitude with the configuration.

```objc
ObjCAnalyticsConfig *config = [[ObjCAnalyticsConfig alloc] init];
config.flushQueueSize = 50;
config.enableCoppaControl = YES;

ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] 
    initWithApiKey:@"YOUR_API_KEY"
    analyticsConfig:config];
```

--------------------------------

### Mock Storage Implementation for Testing

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Provides a mock implementation of the Storage protocol. Use this in tests to simulate data storage and retrieval without interacting with actual storage.

```swift
class MockStorage: Storage {
    var data: [String: Data] = [: ]
    
    func save(key: String, value: Data) {
        data[key] = value
    }
    
    func load(key: String) -> Data? {
        return data[key]
    }
    
    func delete(key: String) {
        data.removeValue(forKey: key)
    }
}
```

--------------------------------

### Implement and Use a Before Plugin

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Create a 'before' plugin to enrich events with data before they are captured. Add the plugin to the Amplitude SDK instance.

```swift
import AmplitudeUnified

class PricingPlugin: Plugin {
    let type: PluginType = .before
    let name = "com.myapp.PricingPlugin"
    
    func execute(event: BaseEvent) -> BaseEvent? {
        // Enrich events with pricing data
        if event.eventType == "Purchase" {
            event.eventProperties?["currency"] = "USD"
        }
        return event
    }
}

// Usage
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
amplitude.add(plugin: PricingPlugin())
```

--------------------------------

### Ingestion Metadata Implementation

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Shows how to implement and configure ingestion metadata for tracking the source and version of the ingestion pipeline.

```swift
public struct IngestionMetadata {
    public let sourceName: String?
    public let sourceVersion: String?
}

let metadata = IngestionMetadata(
    sourceName: "iOS App",
    sourceVersion: "1.0.0"
)
let config = AnalyticsConfig(ingestionMetadata: metadata)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### Multiple Amplitude Instances for Different Pipelines

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Initialize multiple Amplitude instances with distinct API keys and configurations for separate tracking pipelines, such as production and debug events. This allows for isolated data collection.

```swift
// Production events
let productionAmplitude = Amplitude(
    apiKey: "PROD_KEY",
    instanceName: "production",
    analyticsConfig: AnalyticsConfig(useBatch: true)
)

// Debug/test events
let debugAmplitude = Amplitude(
    apiKey: "DEBUG_KEY",
    instanceName: "debug",
    analyticsConfig: AnalyticsConfig(flushQueueSize: 1)
)

// Separate tracking pipelines
productionAmplitude.track(eventType: "User Signup")
debugAmplitude.track(eventType: "Debug Info")
```

--------------------------------

### ObjCAmplitude Constructor

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Initializes an ObjCAmplitude instance for non-iOS platforms without Session Replay support. It takes an API key and several optional configuration parameters.

```APIDOC
## Constructor: init(apiKey:serverZone:instanceName:analyticsConfig:experimentConfig:logger:)

### Description
Initializes an `ObjCAmplitude` instance without Session Replay support. This is intended for non-iOS platforms.

### Method
`init` (Objective-C Constructor)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
(None)

### Parameters
- **apiKey** (String) - Required - API key for Amplitude project
- **serverZone** (AmplitudeCore.ServerZone) - Optional - Server region: `.US` or `.EU`. Defaults to `Configuration.Defaults.serverZone`.
- **instanceName** (String) - Optional - Named instance identifier. Defaults to `Configuration.Defaults.instanceName`.
- **analyticsConfig** (ObjCAnalyticsConfig) - Optional - Analytics configuration. Defaults to `.init()`.
- **experimentConfig** (ExperimentPlugin.Config) - Optional - Experiment configuration. Defaults to `.init()`.
- **logger** (ObjCLoggerProvider?) - Optional - Custom Objective-C logger. Defaults to `nil`.

### Request Example
```objc
ObjCAmplitude *amplitude = [[ObjCAmplitude alloc] init:
    apiKey:@"YOUR_API_KEY"
    serverZone:AmplitudeCore.ServerZone.EU
    instanceName:@"my_instance"
    analyticsConfig:[[ObjCAnalyticsConfig alloc] init]
    experimentConfig:[[ExperimentPlugin.Config alloc] init]
    logger:nil];
```

### Response
#### Success Response
Initializes an `ObjCAmplitude` instance.

#### Response Example
(None - Constructor)
```

--------------------------------

### Amplitude Initialization with Multiple Instances

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initialize multiple Amplitude instances with distinct API keys and names.

```swift
let primary = Amplitude(apiKey: "KEY1", instanceName: "primary")
let secondary = Amplitude(apiKey: "KEY2", instanceName: "secondary")
```

--------------------------------

### Advanced Swift SDK Initialization with Custom Components

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Initialize Amplitude with custom logger, storage, and callback implementations for advanced tracking and data handling. Ensure all custom classes conform to the required protocols.

```swift
// Custom logger
class FileLogger: Logger {
    func debug(_ message: @autoclosure () -> String) {}
    func info(_ message: @autoclosure () -> String) {}
    func warn(_ message: @autoclosure () -> String) {}
    func error(_ message: @autoclosure () -> String) {
        writeToFile(message())
    }
    
    private func writeToFile(_ message: String) {
        // Implementation
    }
}

// Custom storage
class DatabaseStorage: Storage {
    func save(key: String, value: Data) {}
    func load(key: String) -> Data? { nil }
    func delete(key: String) {}
}

// Custom callback
class AnalyticsMonitor: EventCallback {
    func onEvent(status: EventStatus, event: BaseEvent) {
        logEventStatus(status, event: event)
    }
    
    private func logEventStatus(_ status: EventStatus, event: BaseEvent) {
        // Implementation
    }
}

// Full configuration
let config = AnalyticsConfig(
    flushQueueSize: 50,
    flushIntervalMillis: 30000,
    storageProvider: DatabaseStorage(),
    callback: AnalyticsMonitor(),
    useBatch: true,
    plan: Plan(version: "1.0", branch: "production"),
    enableCoppaControl: false
)

let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config,
    logger: FileLogger()
)
```

--------------------------------

### Amplitude Swift SDK Constructor

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/analytics-configuration.md

Use this constructor to initialize the Amplitude Swift SDK with various configuration options. All parameters have default values provided by `Configuration.Defaults`.

```swift
public init(
    flushQueueSize: Int = Configuration.Defaults.flushQueueSize,
    flushIntervalMillis: Int = Configuration.Defaults.flushIntervalMillis,
    storageProvider: (any Storage)? = nil,
    identifyStorageProvider: (any Storage)? = nil,
    minIDLength: Int? = nil,
    partnerID: String? = nil,
    callback: EventCallback? = nil,
    flushMaxRetries: Int = Configuration.Defaults.flushMaxRetries,
    useBatch: Bool = Configuration.Defaults.useBatch,
    serverURL: String? = nil,
    plan: Plan? = nil,
    ingestionMetadata: IngestionMetadata? = nil,
    trackingOptions: TrackingOptions = Configuration.Defaults.trackingOptions,
    enableCoppaControl: Bool = Configuration.Defaults.enableCoppaControl,
    flushEventsOnClose: Bool = Configuration.Defaults.flushEventsOnClose,
    minTimeBetweenSessionsMillis: Int = Configuration.Defaults.minTimeBetweenSessionsMillis,
    autocapture: AutocaptureOptions = Configuration.Defaults.autocaptureOptions,
    identifyBatchIntervalMillis: Int = Configuration.Defaults.identifyBatchIntervalMillis,
    maxQueuedEventCount: Int = Configuration.Defaults.maxQueuedEventCount,
    migrateLegacyData: Bool = Configuration.Defaults.migrateLegacyData,
    enableAutoCaptureRemoteConfig: Bool = Configuration.Defaults.enableAutoCaptureRemoteConfig
)
```

--------------------------------

### Custom Server Endpoint Configuration

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Demonstrates how to configure a custom server URL for sending event data to a specific ingestion endpoint.

```swift
let config = AnalyticsConfig(
    serverURL: "https://custom.amplitude.com/api/2/httpapi"
)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### Automatic Registration of UnifiedSDKPlugin

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/unified-sdk-plugin.md

Demonstrates how the UnifiedSDKPlugin is automatically registered when initializing the Amplitude SDK with the unified interface. It also shows explicit registration via the plugin system.

```swift
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
// UnifiedSDKPlugin is automatically registered internally
```

```swift
amplitude.add(plugin: UnifiedSDKPlugin())
```

--------------------------------

### Amplitude Class Initialization

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/api-reference.md

Initializes the Amplitude Unified SDK for Swift with various configuration options. Supports multiple instances and plugins.

```APIDOC
## Amplitude Class (Extended)

**Module:** `AmplitudeUnified`
**Base:** `Amplitude` from `AmplitudeSwift`

### Initialization

```swift
public extension Amplitude {
    convenience init(
        apiKey: String,
        serverZone: AmplitudeCore.ServerZone = .US,
        instanceName: String = Constants.Configuration.DEFAULT_INSTANCE,
        analyticsConfig: AnalyticsConfig = .init(),
        experimentConfig: ExperimentPlugin.Config = .init(),
        sessionReplayConfig: SessionReplayPlugin.Config = .init(),
        logger: any Logger = ConsoleLogger()
    )
}
```

**Parameters:**
- `apiKey: String` — Required. Amplitude API key for your project
- `serverZone: AmplitudeCore.ServerZone` — Optional, default `.US`. Server region (`.US` or `.EU`)
- `instanceName: String` — Optional, default `Constants.Configuration.DEFAULT_INSTANCE`. Identifier for multiple instances
- `analyticsConfig: AnalyticsConfig` — Optional, default `.init()`. Analytics configuration
- `experimentConfig: ExperimentPlugin.Config` — Optional, default `.init()`. Experiment configuration
- `sessionReplayConfig: SessionReplayPlugin.Config` — Optional, default `.init()`. Session Replay configuration (iOS only)
- `logger: any Logger` — Optional, default `ConsoleLogger()`. Custom logger implementation

**Availability:** iOS 13+, tvOS 13+, macOS 10.15+, watchOS 7+, visionOS 1+

**Inherited Methods** (from AmplitudeSwift):
- `track(eventType: String, eventProperties: [String: Any]?)` — Track an event
- `identify(identify: Identify)` — Update user properties
- `setUserId(userId: String?)` — Set or clear user ID
- `flush()` — Force flush pending events
- `add(plugin: Plugin)` — Register custom plugin
```

--------------------------------

### Add Amplitude Unified SDK via CocoaPods

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/README.md

Instructions for adding the SDK to your Podfile using CocoaPods.

```ruby
pod 'AmplitudeUnified', '~> 0.0'
```

--------------------------------

### Objective-C Initializer (Non-iOS)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/objc-initializer.md

Initializes an ObjCAmplitude instance for non-iOS platforms without Session Replay support. It accepts an API key and optional configurations for server zone, instance name, analytics, experiments, and logging.

```swift
@objc convenience init(
    apiKey: String,
    serverZone: AmplitudeCore.ServerZone = Configuration.Defaults.serverZone,
    instanceName: String = Configuration.Defaults.instanceName,
    analyticsConfig: ObjCAnalyticsConfig = .init(),
    experimentConfig: ExperimentPlugin.Config = .init(),
    logger: ObjCLoggerProvider? = nil
)
```

--------------------------------

### Implement and Use an Event Callback

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/extension-points.md

Create a class that conforms to EventCallback to handle events after they are processed by the SDK. Initialize Amplitude with your callback configuration.

```swift
import AmplitudeUnified

class EventMonitor: EventCallback {
    func onEvent(status: EventStatus, event: BaseEvent) {
        switch status {
        case .success:
            print("Event sent: \(event.eventType ?? "unknown")")
        case .failed:
            print("Event failed: \(event.eventType ?? "unknown")")
        case .retry:
            print("Event retrying: \(event.eventType ?? "unknown")")
        }
    }
}

// Usage
let monitor = EventMonitor()
let config = AnalyticsConfig(callback: monitor)
let amplitude = Amplitude(
    apiKey: "YOUR_API_KEY",
    analyticsConfig: config
)
```

--------------------------------

### Initialize Amplitude on Non-iOS Platforms

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/quick-start.md

Initialize the Amplitude SDK on platforms other than iOS. Session Replay is not available and the corresponding configuration parameter is not accepted.

```swift
let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
// sessionReplayConfig parameter is not accepted
```

--------------------------------

### Global Singleton Amplitude Initialization (Swift)

Source: https://github.com/amplitude/amplitudeunified-swift/blob/main/_autodocs/initialization-patterns.md

Set up Amplitude as a global singleton within your AppDelegate for easy access throughout the application. Ensure it's configured before use.

```swift
import UIKit
import AmplitudeUnified

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    static let amplitude = Amplitude(apiKey: "YOUR_API_KEY")
    
    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Amplitude configured and ready
        AppDelegate.amplitude.track(eventType: "App Launched")
        return true
    }
}

// Usage elsewhere
func someViewController() {
    AppDelegate.amplitude.track(eventType: "Button Tapped")
}
```