> ## Documentation Index
> Fetch the complete documentation index at: https://docs.liv.tv/llms.txt
> Use this file to discover all available pages before exploring further.

# Types & Structs (Unreal)

> Common structs and type definitions used across the LCK SDK for Unreal Engine.

## What Problem Does This Solve?

When working with LCK, you'll pass configuration structs to methods and handle interaction data from UI. This page documents:

* Recording parameters (resolution, bitrate, framerate)
* Camera mode settings (FOV, smoothness, distance)
* UI interaction data (touch events, button states)
* Color palette constants
* Audio source channel configuration and validation
* Audio plugin runtime information
* Telemetry event types

Understanding these types helps you configure recording quality, customize camera behavior, build custom UI, and inspect audio system state.

## When to Use This

Reference this when:

* Configuring recording parameters
* Setting up camera modes
* Handling UI events
* Styling custom UI components
* Working with audio channels and source configuration
* Validating audio plugin configuration before recording
* Querying registered audio plugin capabilities
* Working with telemetry events

***

## Recording Configuration

### FLCKRecorderParams

**What it's for:** Configure video/audio recording settings

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKRecorderParams
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 Width = 1920;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 Height = 1080;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 Framerate = 30;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 VideoBitrate = 2 << 20;  // 2097152 (~2 Mbps)

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 Samplerate = 48000;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 AudioBitrate = 256 << 10;   // 262144 (~256 Kbps)
};
```

| Field          | Type    | Default              | Description             | Range        |
| -------------- | ------- | -------------------- | ----------------------- | ------------ |
| `Width`        | `int32` | 1920                 | Video width in pixels   | 640-3840     |
| `Height`       | `int32` | 1080                 | Video height in pixels  | 480-2160     |
| `Framerate`    | `int32` | 30                   | Frames per second       | 15-120       |
| `VideoBitrate` | `int32` | `2 << 20` (2097152)  | Video bitrate in bps    | 500k-100M    |
| `Samplerate`   | `int32` | 48000                | Audio sample rate in Hz | 44100, 48000 |
| `AudioBitrate` | `int32` | `256 << 10` (262144) | Audio bitrate in bps    | 64k-512k     |

**Common use:**

```cpp theme={null}
// HD recording at 60 FPS
FLCKRecorderParams Params;
Params.Width = 1920;
Params.Height = 1080;
Params.Framerate = 60;
Params.VideoBitrate = 12 << 20;  // 12 Mbps
Params.AudioBitrate = 256000;   // 256 Kbps

Recorder->SetupRecorder(Params, CaptureComponent);
```

***

### FLCKRecordingProfileSettings

**What it's for:** Predefined quality profiles (configured in Project Settings)

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKRecordingProfileSettings
{
    GENERATED_BODY()
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    int32 Width = 1280;
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    int32 Height = 720;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "15", ClampMax = "120"))
    int32 Framerate = 30;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "500000", ClampMax = "100000000"))
    int32 VideoBitrate = 4000000;  // 4 Mbps
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "64000", ClampMax = "512000"))
    int32 AudioBitrate = 128000;   // 128 Kbps
    
    UPROPERTY(BlueprintReadOnly)
    int32 Samplerate = 48000;
};
```

**Typical profiles:**

| Quality | Resolution | Bitrate | FPS | Use Case                  |
| ------- | ---------- | ------- | --- | ------------------------- |
| SD      | 1280×720   | 4 Mbps  | 30  | Mobile, performance mode  |
| HD      | 1920×1080  | 12 Mbps | 60  | Standard quality          |
| 2K      | 2560×1440  | 20 Mbps | 60  | High quality              |
| 4K      | 3840×2160  | 35 Mbps | 60  | Maximum quality (PC only) |

***

## Camera Mode Settings

### FLCKSelfieModeDefaults

**What it's for:** Default settings for Selfie camera mode

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKSelfieModeDefaults
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "20.0", ClampMax = "120.0"))
    float FOV = 80.0f;
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "0.0", ClampMax = "100.0"))
    float Smoothness = 50.0f;
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "0.5", ClampMax = "10.0"))
    float FollowDistance = 2.0f;
    
    UPROPERTY(EditAnywhere)
    bool bFollowEnabled = false;
};
```

| Field            | Type    | Default | Description                    | Range    |
| ---------------- | ------- | ------- | ------------------------------ | -------- |
| `FOV`            | `float` | 80.0    | Field of view in degrees       | 20-120   |
| `Smoothness`     | `float` | 50.0    | Camera movement smoothing      | 0-100    |
| `FollowDistance` | `float` | 2.0     | Distance from player in meters | 0.5-10.0 |
| `bFollowEnabled` | `bool`  | false   | Auto-follow player movement    | -        |

**Example:**

```cpp theme={null}
// Selfie mode with auto-follow
FLCKSelfieModeDefaults Selfie;
Selfie.FOV = 75.0f;
Selfie.Smoothness = 60.0f;
Selfie.FollowDistance = 1.5f;
Selfie.bFollowEnabled = true;
```

***

### FLCKFirstPersonModeDefaults

**What it's for:** Default settings for First Person camera mode

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKFirstPersonModeDefaults
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "20.0", ClampMax = "120.0"))
    float FOV = 90.0f;
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "0.0", ClampMax = "100.0"))
    float Smoothness = 75.0f;
};
```

| Field        | Type    | Default | Description                   |
| ------------ | ------- | ------- | ----------------------------- |
| `FOV`        | `float` | 90.0    | Field of view (wider for FPS) |
| `Smoothness` | `float` | 75.0    | Camera lag for head movement  |

**Typical values:**

* **Low smoothness (0-30):** Sharp, responsive (competitive FPS)
* **Medium smoothness (40-70):** Balanced (standard FPS)
* **High smoothness (80-100):** Cinematic feel (story-driven)

***

### FLCKThirdPersonModeDefaults

**What it's for:** Default settings for Third Person camera mode

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKThirdPersonModeDefaults
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "20.0", ClampMax = "120.0"))
    float FOV = 90.0f;
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "0.0", ClampMax = "100.0"))
    float Smoothness = 100.0f;
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "0.5", ClampMax = "10.0"))
    float Distance = 2.0f;
    
    UPROPERTY(EditAnywhere, meta = (ClampMin = "-90.0", ClampMax = "90.0"))
    float PitchAngle = -30.0f;
};
```

| Field        | Type    | Default | Description                         |
| ------------ | ------- | ------- | ----------------------------------- |
| `FOV`        | `float` | 90.0    | Field of view                       |
| `Smoothness` | `float` | 100.0   | Camera lag (very smooth)            |
| `Distance`   | `float` | 2.0     | Distance behind player in meters    |
| `PitchAngle` | `float` | -30.0   | Vertical angle (-90 to +90 degrees) |

**Example:**

```cpp theme={null}
// Over-the-shoulder camera
FLCKThirdPersonModeDefaults ThirdPerson;
ThirdPerson.FOV = 85.0f;
ThirdPerson.Distance = 1.5f;
ThirdPerson.PitchAngle = -20.0f;  // Slightly above shoulder
ThirdPerson.Smoothness = 90.0f;
```

***

## UI Interaction Data

### FLCKTapData

**What it's for:** Touch/pointer interaction event data from UI buttons

```cpp theme={null}
USTRUCT()
struct LCKUI_API FLCKTapData
{
    GENERATED_BODY()
    
    UPROPERTY()
    FVector ButtonLocation = FVector::ZeroVector;
    
    UPROPERTY()
    FVector ButtonRightVector = FVector::ZeroVector;
    
    UPROPERTY()
    FVector ButtonForwardVector = FVector::ZeroVector;
    
    UPROPERTY()
    FVector TapLocation = FVector::ZeroVector;
    
    UPROPERTY()
    bool IsPressed = false;
};
```

| Field                 | Type      | Description                         |
| --------------------- | --------- | ----------------------------------- |
| `ButtonLocation`      | `FVector` | World position of the button        |
| `ButtonRightVector`   | `FVector` | Button's local right direction      |
| `ButtonForwardVector` | `FVector` | Button's local forward direction    |
| `TapLocation`         | `FVector` | World position of tap/click         |
| `IsPressed`           | `bool`    | Whether button is currently pressed |

**When you'll see this:** Inside button interaction callbacks

```cpp theme={null}
Button->OnTapStarted.AddDynamic(this, &AMyActor::HandleButtonTap);

void AMyActor::HandleButtonTap(const FLCKTapData& TapData)
{
    UE_LOG(LogTemp, Log, TEXT("Button at %s pressed"), 
        *TapData.ButtonLocation.ToString());
}
```

***

## UI Styling

### FLCKColor

**What it's for:** Standard color palette for LCK UI components

```cpp theme={null}
USTRUCT()
struct LCKUI_API FLCKColor
{
    static constexpr FColor Primary         {8, 8, 8};       // #080808
    static constexpr FColor PrimaryText     {220, 220, 220}; // #DCDCDC
    static constexpr FColor Secondary       {16, 16, 16};    // #101010
    static constexpr FColor Disabled        {96, 96, 96};    // #606060
    static constexpr FColor ButtonDefault   {40, 40, 40};    // #282828
    static constexpr FColor ButtonIconDefault {220, 220, 220}; // #DCDCDC
    static constexpr FColor ButtonActive    {94, 69, 255};   // #5E45FF
    static constexpr FColor Debug           {255, 0, 255};   // #FF00FF
    static constexpr FColor Alert           {255, 42, 42};   // #FF2A2A
    static constexpr FColor Success         {32, 196, 64};   // #20C440
    static constexpr FColor White           {255, 255, 255}; // #FFFFFF
    static constexpr FColor Black           {0, 0, 0};       // #000000
};
```

| Color           | RGB             | Hex       | Use Case                    |
| --------------- | --------------- | --------- | --------------------------- |
| `Primary`       | (8, 8, 8)       | `#080808` | Main background             |
| `PrimaryText`   | (220, 220, 220) | `#DCDCDC` | Primary text                |
| `Secondary`     | (16, 16, 16)    | `#101010` | Secondary background        |
| `Disabled`      | (96, 96, 96)    | `#606060` | Disabled UI elements        |
| `ButtonDefault` | (40, 40, 40)    | `#282828` | Default button color        |
| `ButtonActive`  | (94, 69, 255)   | `#5E45FF` | Active/pressed button       |
| `Alert`         | (255, 42, 42)   | `#FF2A2A` | Recording indicator, errors |
| `Success`       | (32, 196, 64)   | `#20C440` | Success state               |

**Example usage:**

```cpp theme={null}
// Set button color based on state
if (bIsRecording)
{
    ButtonMaterial->SetVectorParameterValue(
        TEXT("BaseColor"), 
        FLinearColor(FLCKColor::Alert)
    );
}
else
{
    ButtonMaterial->SetVectorParameterValue(
        TEXT("BaseColor"), 
        FLinearColor(FLCKColor::ButtonDefault)
    );
}
```

***

## Audio Channel Bitmask

### TLCKAudioChannelsMask

**What it's for:** Combine multiple audio channels using bitwise operations

```cpp theme={null}
typedef uint64 TLCKAudioChannelsMask;
```

**Usage:**

```cpp theme={null}
// Combine game audio + microphone
TLCKAudioChannelsMask Channels = 
    ELCKAudioChannel::Game | ELCKAudioChannel::Microphone;

// Check if mask contains microphone
bool HasMic = (Channels & ELCKAudioChannel::Microphone) != 0;

// Start capture with both channels
AudioSource->StartCapture(Channels);
```

**Common combinations:**

```cpp theme={null}
// Game audio only
TLCKAudioChannelsMask GameOnly = ELCKAudioChannel::Game;

// Microphone only
TLCKAudioChannelsMask MicOnly = ELCKAudioChannel::Microphone;

// Game + Mic (typical recording)
TLCKAudioChannelsMask Standard = 
    ELCKAudioChannel::Game | ELCKAudioChannel::Microphone;

// Game + Mic + Voice chat
TLCKAudioChannelsMask AllChannels = 
    ELCKAudioChannel::Game | 
    ELCKAudioChannel::Microphone | 
    ELCKAudioChannel::VoiceChat;
```

***

## Button UI Types

### ELCKButtonType

**What it's for:** Define button shape and size for 3D UI

```cpp theme={null}
UENUM(BlueprintType)
enum class ELCKButtonType : uint8
{
    Square      UMETA(DisplayName = "Square"),
    Rectangle   UMETA(DisplayName = "Rectangle"),
    Tab         UMETA(DisplayName = "Tab"),
    Selector    UMETA(DisplayName = "Selector")
};
```

| Type        | Box Extent (cm) | Aspect Ratio | Use Case                     |
| ----------- | --------------- | ------------ | ---------------------------- |
| `Square`    | (0.4, 2.4, 2.4) | 1:1          | Icons, single-action buttons |
| `Rectangle` | (0.4, 6.0, 2.4) | 2.5:1        | Text buttons, labels         |
| `Tab`       | (0.4, 4.4, 2.4) | 1.83:1       | Tab navigation               |
| `Selector`  | (2.4, 4.4, 0.8) | 5.5:1        | Sliders, selectors           |

***

## Complete Configuration Example

```cpp theme={null}
void AMyRecorder::SetupRecording()
{
    // 1. Configure recorder params
    FLCKRecorderParams Params;
    Params.Width = 1920;
    Params.Height = 1080;
    Params.Framerate = 60;
    Params.VideoBitrate = 10 << 20;  // 10 Mbps
    Params.AudioBitrate = 256000;    // 256 Kbps
    
    // 2. Set up camera mode
    FLCKThirdPersonModeDefaults ThirdPerson;
    ThirdPerson.FOV = 85.0f;
    ThirdPerson.Distance = 2.0f;
    ThirdPerson.PitchAngle = -25.0f;
    ThirdPerson.Smoothness = 90.0f;
    
    // 3. Configure audio channels
    TLCKAudioChannelsMask Channels = 
        ELCKAudioChannel::Game | ELCKAudioChannel::Microphone;
    
    // 4. Start recording
    ULCKRecorderSubsystem* Recorder = GetWorld()->GetSubsystem<ULCKRecorderSubsystem>();
    Recorder->SetupRecorder(Params, CaptureComponent);
    Recorder->StartRecording();
}
```

***

## Audio Source Channel Presets

### FLCKAudioSourceChannels

**What it's for:** Default channel configuration enabling both microphone and game audio capture.

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKAudioSourceChannels
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool bMicrophoneEnabled = true;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool bGameAudioEnabled = true;
};
```

| Field                | Type   | Default | Description               |
| -------------------- | ------ | ------- | ------------------------- |
| `bMicrophoneEnabled` | `bool` | `true`  | Enable microphone capture |
| `bGameAudioEnabled`  | `bool` | `true`  | Enable game audio capture |

***

### FLCKAudioSourceGameOnly

**What it's for:** Channel preset for sources that only provide game audio (e.g., FMOD, Wwise).

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKAudioSourceGameOnly
{
    GENERATED_BODY()

    UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Audio")
    bool bGameAudioEnabled = true;
};
```

| Field               | Type   | Default | Description               |
| ------------------- | ------ | ------- | ------------------------- |
| `bGameAudioEnabled` | `bool` | `true`  | Enable game audio capture |

***

### FLCKAudioSourceMicOnly

**What it's for:** Channel preset for sources that only provide microphone input (e.g., Oboe on Android).

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKAudioSourceMicOnly
{
    GENERATED_BODY()

    UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Audio")
    bool bMicrophoneEnabled = true;
};
```

| Field                | Type   | Default | Description               |
| -------------------- | ------ | ------- | ------------------------- |
| `bMicrophoneEnabled` | `bool` | `true`  | Enable microphone capture |

***

### FLCKAudioSourceVoiceChat

**What it's for:** Channel preset for voice chat sources that capture microphone and incoming voice audio (e.g., Vivox).

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKAudioSourceVoiceChat
{
    GENERATED_BODY()

    UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Audio")
    bool bMicrophoneEnabled = true;

    UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Audio")
    bool bVoiceAudioEnabled = true;
};
```

| Field                | Type   | Default | Description                 |
| -------------------- | ------ | ------- | --------------------------- |
| `bMicrophoneEnabled` | `bool` | `true`  | Outgoing microphone capture |
| `bVoiceAudioEnabled` | `bool` | `true`  | Incoming voice chat audio   |

***

## Audio Configuration Validation

### FLCKAudioConfigValidation

**What it's for:** Result of validating the current audio plugin configuration. Returned by the audio system to report issues such as missing microphone sources or duplicate game audio plugins.

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKAudioConfigValidation
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    bool bIsValid = true;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    TArray<FString> Warnings;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    ELCKGameAudioType ActiveGameAudio = ELCKGameAudioType::None;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    bool bHasMicrophoneSource = false;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    int32 MicrophoneSourceCount = 0;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    TArray<FString> EnabledMicrophoneSources;
};
```

| Field                      | Type                | Default | Description                                     |
| -------------------------- | ------------------- | ------- | ----------------------------------------------- |
| `bIsValid`                 | `bool`              | `true`  | Whether the audio config is valid for recording |
| `Warnings`                 | `TArray<FString>`   | `[]`    | Human-readable warning messages                 |
| `ActiveGameAudio`          | `ELCKGameAudioType` | `None`  | The active game audio middleware type           |
| `bHasMicrophoneSource`     | `bool`              | `false` | Whether at least one mic source is available    |
| `MicrophoneSourceCount`    | `int32`             | `0`     | Number of registered microphone sources         |
| `EnabledMicrophoneSources` | `TArray<FString>`   | `[]`    | Names of all enabled microphone sources         |

**Common use:**

```cpp theme={null}
FLCKAudioConfigValidation Validation = AudioSystem->ValidateConfig();

if (!Validation.bIsValid)
{
    for (const FString& Warning : Validation.Warnings)
    {
        UE_LOG(LogLCK, Warning, TEXT("Audio config: %s"), *Warning);
    }
}
```

***

## Audio Plugin Info

### FLCKAudioPluginInfo

**What it's for:** Describes a registered audio plugin and its capabilities. Used by the audio system to enumerate available plugins at runtime.

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKAudioPluginInfo
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    FString ModuleName;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    FString DisplayName;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    bool bIsLoaded = false;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    bool bMicrophoneEnabled = false;

    UPROPERTY(BlueprintReadOnly, Category = "LCK")
    bool bGameAudioEnabled = false;
};
```

| Field                | Type      | Default | Description                                 |
| -------------------- | --------- | ------- | ------------------------------------------- |
| `ModuleName`         | `FString` | `""`    | Module name (e.g., `"LCKFMOD"`)             |
| `DisplayName`        | `FString` | `""`    | Human-readable name (e.g., `"FMOD Studio"`) |
| `bIsLoaded`          | `bool`    | `false` | Whether the module is currently loaded      |
| `bMicrophoneEnabled` | `bool`    | `false` | Plugin supports microphone capture          |
| `bGameAudioEnabled`  | `bool`    | `false` | Plugin supports game audio capture          |

***

## Telemetry Types

### FLCKTelemetryValue

**What it's for:** A variant value type used in telemetry events to hold different data types in a single field.

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKTelemetryValue
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    int32 IntValue = 0;

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    float FloatValue = 0.0f;

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    FString StringValue;

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    bool BoolValue = false;

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    uint8 ValueType = 0; // 0 = Int, 1 = Float, 2 = String, 3 = Bool
};
```

| Field         | Type      | Default | Description                                             |
| ------------- | --------- | ------- | ------------------------------------------------------- |
| `IntValue`    | `int32`   | `0`     | Integer payload (used when `ValueType == "Int"`)        |
| `FloatValue`  | `float`   | `0.0`   | Float payload (used when `ValueType == "Float"`)        |
| `StringValue` | `FString` | `""`    | String payload (used when `ValueType == "String"`)      |
| `BoolValue`   | `bool`    | `false` | Boolean payload (used when `ValueType == "Bool"`)       |
| `ValueType`   | `uint8`   | `0`     | Discriminator: 0 = Int, 1 = Float, 2 = String, 3 = Bool |

***

### FLCKTelemetryEvent

**What it's for:** Represents a single telemetry event with a type identifier and a map of contextual key-value pairs.

```cpp theme={null}
USTRUCT(BlueprintType)
struct FLCKTelemetryEvent
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    ELCKTelemetryEventType EventType = ELCKTelemetryEventType::GameInitialized;

    UPROPERTY(BlueprintReadWrite, Category = "LCK Telemetry")
    TMap<FString, FLCKTelemetryValue> Context;
};
```

| Field       | Type                                | Default           | Description                       |
| ----------- | ----------------------------------- | ----------------- | --------------------------------- |
| `EventType` | `ELCKTelemetryEventType`            | `GameInitialized` | Event type enum value             |
| `Context`   | `TMap<FString, FLCKTelemetryValue>` | `{}`              | Key-value pairs of event metadata |

**Common use:**

```cpp theme={null}
FLCKTelemetryEvent Event;
Event.EventType = ELCKTelemetryEventType::RecordingStarted;

FLCKTelemetryValue ResolutionValue;
ResolutionValue.StringValue = TEXT("1920x1080");
ResolutionValue.ValueType = 2; // String
Event.Context.Add(TEXT("Resolution"), ResolutionValue);
```

***

## Key Takeaways

<Check>**FLCKRecorderParams** — Configure video/audio quality</Check>
<Check>**Camera mode structs** — Customize camera behavior (FOV, smoothness, distance)</Check>
<Check>**FLCKTapData** — Handle UI button interactions</Check>
<Check>**FLCKColor** — Use standard color palette for consistency</Check>
<Check>**TLCKAudioChannelsMask** — Combine audio channels with bitwise OR</Check>
<Check>**Audio channel presets** — FLCKAudioSourceChannels, GameOnly, MicOnly, VoiceChat</Check>
<Check>**FLCKAudioConfigValidation** — Validate audio plugin configuration before recording</Check>
<Check>**FLCKAudioPluginInfo** — Enumerate registered audio plugins at runtime</Check>
<Check>**Telemetry types** — FLCKTelemetryValue and FLCKTelemetryEvent for analytics</Check>

***

## Related

* [Enums Reference](/api-reference/unreal/enums) — All enum values
* [Architecture](/api-reference/unreal/architecture) — How these types are used
* [Recording Guide](/unreal/core-sdk/recording) — Practical recording setup