@dendotdev/grunt 1.0.8 → 1.0.10

package/dist/index.d.ts

@@ -226,7 +226,7 @@ interface RawResponse {
  * const result = await client.stats.getMatchStats('match-id');
  * if (isSuccess(result)) {
  *   // TypeScript now knows result.result is non-null
- *   console.log(result.result.matchId);
+ *   console.log(result.result.MatchId);
  * }
  * ```
  */
@@ -711,22 +711,22 @@ declare abstract class ModuleBase {
  */
 interface BanResult {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Whether player is banned */
-    isBanned?: boolean;
+    IsBanned?: boolean;
     /** Ban reason */
-    reason?: string;
+    Reason?: string;
     /** Ban expiration (ISO 8601) */
-    expiresAt?: string;
+    ExpiresAt?: string;
     /** Severity level */
-    severity?: string;
+    Severity?: string;
 }
 /**
  * Container for ban query results.
  */
 interface BansSummaryQueryResult {
     /** List of ban results */
-    results?: BanResult[];
+    Results?: BanResult[];
 }
 
 /**
@@ -734,75 +734,75 @@ interface BansSummaryQueryResult {
  */
 interface Server {
     /** Server region */
-    region?: string;
+    Region?: string;
     /** Server address */
-    address?: string;
+    Address?: string;
     /** Server port */
-    port?: number;
+    Port?: number;
     /** Server name */
-    name?: string;
+    Name?: string;
     /** Whether server is available */
-    available?: boolean;
+    Available?: boolean;
 }
 /**
  * Lobby presence request.
  */
 interface LobbyPresenceRequest {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Session ID */
-    sessionId?: string;
+    SessionId?: string;
 }
 /**
  * Container for lobby presence requests.
  */
 interface LobbyPresenceRequestContainer {
     /** List of presence requests */
-    requests?: LobbyPresenceRequest[];
+    Requests?: LobbyPresenceRequest[];
 }
 /**
  * Lobby presence result.
  */
 interface LobbyPresenceResult {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Session ID */
-    sessionId?: string;
+    SessionId?: string;
     /** Lobby ID */
-    lobbyId?: string;
+    LobbyId?: string;
     /** Whether player is in lobby */
-    inLobby?: boolean;
+    InLobby?: boolean;
 }
 /**
  * Container for lobby presence results.
  */
 interface LobbyPresenceContainer {
     /** List of presence results */
-    results?: LobbyPresenceResult[];
+    Results?: LobbyPresenceResult[];
 }
 /**
  * Lobby join handle.
  */
 interface LobbyJoinHandle {
     /** Handle identifier */
-    handleId?: string;
+    HandleId?: string;
     /** Lobby ID */
-    lobbyId?: string;
+    LobbyId?: string;
     /** Handle value */
-    handle?: string;
+    Handle?: string;
     /** Expiration time (ISO 8601) */
-    expiresAt?: string;
+    ExpiresAt?: string;
 }
 /**
  * Response when joining a lobby.
  */
 interface JoinLobbyResponse {
     /** Success status */
-    success?: boolean;
+    Success?: boolean;
     /** Lobby ID */
-    lobbyId?: string;
+    LobbyId?: string;
     /** Session details */
-    session?: Record<string, unknown>;
+    Session?: Record<string, unknown>;
 }
 
 /**
@@ -810,86 +810,86 @@ interface JoinLobbyResponse {
  */
 interface PlayerItem {
     /** Item path identifier */
-    itemPath?: string;
+    ItemPath?: string;
     /** Item type */
-    itemType?: string;
+    ItemType?: string;
     /** Quantity owned */
-    amount?: number;
+    Amount?: number;
     /** When first acquired (ISO 8601) */
-    firstAcquiredDate?: string;
+    FirstAcquiredDate?: string;
     /** Source of acquisition */
-    source?: string;
+    Source?: string;
 }
 /**
  * Player inventory response.
  */
 interface PlayerInventory {
     /** List of inventory items */
-    items?: PlayerItem[];
+    Items?: PlayerItem[];
 }
 /**
  * Currency balance.
  */
 interface CurrencyAmount {
     /** Currency identifier */
-    currencyId?: string;
+    CurrencyId?: string;
     /** Current balance */
-    amount?: number;
+    Amount?: number;
 }
 /**
  * Currency snapshot containing all balances.
  */
 interface CurrencySnapshot {
     /** List of currency balances */
-    currencies?: CurrencyAmount[];
+    Currencies?: CurrencyAmount[];
 }
 /**
  * Currency definition from CMS.
  */
 interface CurrencyDefinition {
     /** Currency identifier */
-    currencyId?: string;
+    CurrencyId?: string;
     /** Display title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    image?: string;
+    Image?: string;
     /** Icon type */
-    iconType?: string;
+    IconType?: string;
 }
 /**
  * Localized display string.
  */
 interface DisplayString {
     /** Status of the localization */
-    status?: string;
+    Status?: string;
     /** Default/fallback value */
-    value?: string;
+    Value?: string;
     /** Translations by locale code */
-    translations?: Record<string, string>;
+    Translations?: Record<string, string>;
 }
 /**
  * Inventory amount with details.
  */
 interface InventoryAmount {
     /** Item path */
-    itemPath?: string;
+    ItemPath?: string;
     /** Quantity */
-    amount?: number;
+    Amount?: number;
     /** Item type */
-    itemType?: string;
+    ItemType?: string;
 }
 /**
  * Transaction result after currency operation.
  */
 interface TransactionSnapshot {
     /** Transaction identifier */
-    transactionId?: string;
+    TransactionId?: string;
     /** New balance after transaction */
-    newBalance?: CurrencyAmount[];
+    NewBalance?: CurrencyAmount[];
     /** Transaction timestamp (ISO 8601) */
-    timestamp?: string;
+    Timestamp?: string;
 }
 
 /**
@@ -897,45 +897,45 @@ interface TransactionSnapshot {
  */
 interface Medal {
     /** Medal name identifier */
-    nameId?: number;
+    NameId?: number;
     /** Display name */
-    name?: DisplayString;
+    Name?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Sprite index */
-    spriteIndex?: number;
+    SpriteIndex?: number;
     /** Medal type */
-    type?: string;
+    Type?: string;
     /** Difficulty level */
-    difficulty?: string;
+    Difficulty?: string;
     /** Personal score awarded */
-    personalScore?: number;
+    PersonalScore?: number;
     /** Sorting weight */
-    sortingWeight?: number;
+    SortingWeight?: number;
 }
 /**
  * Medal metadata collection.
  */
 interface MedalMetadata {
     /** List of medals */
-    medals?: Medal[];
+    Medals?: Medal[];
     /** Sprite sheet information */
-    spriteSheet?: SpriteSheet;
+    SpriteSheet?: SpriteSheet;
 }
 /**
  * Sprite sheet information.
  */
 interface SpriteSheet {
     /** Path to sprite sheet image */
-    path?: string;
+    Path?: string;
     /** Sprite width */
-    spriteWidth?: number;
+    SpriteWidth?: number;
     /** Sprite height */
-    spriteHeight?: number;
+    SpriteHeight?: number;
     /** Number of columns */
-    columns?: number;
+    Columns?: number;
     /** Number of rows */
-    rows?: number;
+    Rows?: number;
 }
 
 /**
@@ -943,116 +943,116 @@ interface SpriteSheet {
  */
 interface AcademyClientManifest {
     /** List of categories */
-    categories?: AcademyCategory[];
+    Categories?: AcademyCategory[];
     /** Version */
-    version?: string;
+    Version?: string;
 }
 /**
  * Academy category.
  */
 interface AcademyCategory {
     /** Category identifier */
-    id?: string;
+    Id?: string;
     /** Category title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Category description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    imagePath?: string;
+    ImagePath?: string;
     /** Series in this category */
-    series?: AcademySeries[];
+    Series?: AcademySeries[];
 }
 /**
  * Academy series (collection of drills).
  */
 interface AcademySeries {
     /** Series identifier */
-    id?: string;
+    Id?: string;
     /** Series title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    imagePath?: string;
+    ImagePath?: string;
     /** Drills in this series */
-    drills?: AcademyDrill[];
+    Drills?: AcademyDrill[];
 }
 /**
  * Academy drill.
  */
 interface AcademyDrill {
     /** Drill identifier */
-    id?: string;
+    Id?: string;
     /** Drill title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    imagePath?: string;
+    ImagePath?: string;
     /** Difficulty level */
-    difficulty?: string;
+    Difficulty?: string;
     /** Weapon path */
-    weaponPath?: string;
+    WeaponPath?: string;
     /** Map asset ID */
-    mapAssetId?: string;
+    MapAssetId?: string;
     /** Game variant asset ID */
-    gameVariantAssetId?: string;
+    GameVariantAssetId?: string;
 }
 /**
  * Academy star definitions.
  */
 interface AcademyStarDefinitions {
     /** Star definitions by drill */
-    definitions?: Record<string, AcademyStarDefinition>;
+    Definitions?: Record<string, AcademyStarDefinition>;
 }
 /**
  * Star thresholds for a drill.
  */
 interface AcademyStarDefinition {
     /** One star threshold */
-    oneStar?: number;
+    OneStar?: number;
     /** Two stars threshold */
-    twoStars?: number;
+    TwoStars?: number;
     /** Three stars threshold */
-    threeStars?: number;
+    ThreeStars?: number;
 }
 /**
  * Bot customization data.
  */
 interface BotCustomizationData {
     /** Available bot difficulty levels */
-    difficulties?: BotDifficulty[];
+    Difficulties?: BotDifficulty[];
     /** Bot appearance options */
-    appearances?: BotAppearance[];
+    Appearances?: BotAppearance[];
 }
 /**
  * Bot difficulty level.
  */
 interface BotDifficulty {
     /** Difficulty identifier */
-    id?: string;
+    Id?: string;
     /** Display name */
-    name?: DisplayString;
+    Name?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
 }
 /**
  * Bot appearance option.
  */
 interface BotAppearance {
     /** Appearance identifier */
-    id?: string;
+    Id?: string;
     /** Display name */
-    name?: DisplayString;
+    Name?: DisplayString;
     /** Appearance path */
-    path?: string;
+    Path?: string;
 }
 /**
  * Test academy client manifest (for flighted content).
  */
 interface TestAcademyClientManifest extends AcademyClientManifest {
     /** Flight identifier */
-    flightId?: string;
+    FlightId?: string;
 }
 
 /**
@@ -1060,114 +1060,114 @@ interface TestAcademyClientManifest extends AcademyClientManifest {
  */
 interface Configuration {
     /** Authority definitions */
-    authorities?: Record<string, Authority>;
+    Authorities?: Record<string, Authority>;
     /** Retry policy definitions */
-    retryPolicies?: Record<string, RetryPolicyConfig>;
+    RetryPolicies?: Record<string, RetryPolicyConfig>;
     /** Settings values */
-    settings?: SettingsConfig;
+    Settings?: SettingsConfig;
     /** Endpoint definitions */
-    endpoints?: Record<string, OnlineUriReference>;
+    Endpoints?: Record<string, OnlineUriReference>;
 }
 /**
  * Authority (API service) definition.
  */
 interface Authority {
     /** Authority identifier */
-    authorityId?: string;
+    AuthorityId?: string;
     /** URL scheme (1 = http, 2 = https) */
-    scheme?: number;
+    Scheme?: number;
     /** Hostname */
-    hostname?: string;
+    Hostname?: string;
     /** Port number */
-    port?: number;
+    Port?: number;
     /** Authentication methods */
-    authenticationMethods?: number[];
+    AuthenticationMethods?: number[];
 }
 /**
  * Retry policy configuration.
  */
 interface RetryPolicyConfig {
     /** Policy identifier */
-    retryPolicyId?: string;
+    RetryPolicyId?: string;
     /** Timeout in milliseconds */
-    timeoutMs?: number;
+    TimeoutMs?: number;
     /** Retry options */
-    retryOptions?: RetryOptionsConfig;
+    RetryOptions?: RetryOptionsConfig;
 }
 /**
  * Retry options.
  */
 interface RetryOptionsConfig {
     /** Maximum retry count */
-    maxRetryCount?: number;
+    MaxRetryCount?: number;
     /** Initial retry delay in milliseconds */
-    retryDelayMs?: number;
+    RetryDelayMs?: number;
     /** Retry delay growth factor */
-    retryGrowth?: number;
+    RetryGrowth?: number;
     /** Random jitter to add in milliseconds */
-    retryJitterMs?: number;
+    RetryJitterMs?: number;
     /** Whether to retry on 404 */
-    retryIfNotFound?: boolean;
+    RetryIfNotFound?: boolean;
 }
 /**
  * Online URI reference (endpoint definition).
  */
 interface OnlineUriReference {
     /** Endpoint identifier */
-    endpointId?: string;
+    EndpointId?: string;
     /** Authority identifier */
-    authorityId?: string;
+    AuthorityId?: string;
     /** Path template */
-    path?: string;
+    Path?: string;
     /** Query string template */
-    queryString?: string;
+    QueryString?: string;
     /** Retry policy identifier */
-    retryPolicyId?: string;
+    RetryPolicyId?: string;
     /** Topic name */
-    topicName?: string;
+    TopicName?: string;
     /** Acknowledgement type */
-    acknowledgementTypeId?: number;
+    AcknowledgementTypeId?: number;
     /** Whether auth lifetime extension is supported */
-    authenticationLifetimeExtensionSupported?: boolean;
+    AuthenticationLifetimeExtensionSupported?: boolean;
     /** Whether endpoint is clearance-aware */
-    clearanceAware?: boolean;
+    ClearanceAware?: boolean;
 }
 /**
  * Settings configuration.
  */
 interface SettingsConfig {
     /** CELL config */
-    cellConfig?: string;
+    CellConfig?: string;
     /** Client QoS timeout */
-    clientQoSTimeoutMs?: string;
+    ClientQoSTimeoutMs?: string;
     /** Clearance audience */
-    clearanceAudience?: string;
+    ClearanceAudience?: string;
     /** Playfab title ID */
-    playfabTitleId?: string;
+    PlayfabTitleId?: string;
     /** Title ID list */
-    titleIdList?: string;
+    TitleIdList?: string;
     /** XSTS audience URI */
-    haloXSTSAudienceUri?: string;
+    HaloXSTSAudienceUri?: string;
     /** Product access list */
-    productAccessList?: string;
+    ProductAccessList?: string;
 }
 /**
  * Flight feature flags.
  */
 interface FlightedFeatureFlags {
     /** Flight identifier */
-    flightId?: string;
+    FlightId?: string;
     /** Clearance identifier */
-    clearanceId?: string;
+    ClearanceId?: string;
     /** Feature flags */
-    flags?: Record<string, boolean>;
+    Flags?: Record<string, boolean>;
 }
 /**
  * Player clearance/flight configuration ID.
  */
 interface PlayerClearance {
     /** Flight configuration identifier */
-    flightConfigurationId?: string;
+    FlightConfigurationId?: string;
 }
 
 /**
@@ -1175,118 +1175,118 @@ interface PlayerClearance {
  */
 interface NewsArticle {
     /** Article identifier */
-    id?: number;
+    Id?: number;
     /** Featured image URL */
-    featuredImageUri?: string;
+    FeaturedImageUri?: string;
     /** Featured image alt text */
-    featuredImageAlt?: string;
+    FeaturedImageAlt?: string;
     /** Article title */
-    title?: string;
+    Title?: string;
     /** Article subtitle */
-    subtitle?: string;
+    Subtitle?: string;
     /** Article content (HTML) */
-    content?: string;
+    Content?: string;
     /** Short excerpt */
-    excerpt?: string;
+    Excerpt?: string;
     /** URL slug */
-    slug?: string;
+    Slug?: string;
     /** Creator slug */
-    creatorSlug?: string;
+    CreatorSlug?: string;
     /** Creator title */
-    creatorTitle?: string;
+    CreatorTitle?: string;
     /** Category IDs */
-    categories?: number[];
+    Categories?: number[];
     /** Tags */
-    tags?: string[];
+    Tags?: string[];
     /** Publish date (ISO 8601) */
-    publishDate?: string;
+    PublishDate?: string;
     /** Medium image URL */
-    featuredImageUriMedium?: string;
+    FeaturedImageUriMedium?: string;
     /** Medium image alt */
-    featuredImageAltMedium?: string;
+    FeaturedImageAltMedium?: string;
     /** Small image URL */
-    featuredImageUriSmall?: string;
+    FeaturedImageUriSmall?: string;
     /** Small image alt */
-    featuredImageAltSmall?: string;
+    FeaturedImageAltSmall?: string;
 }
 /**
  * News collection.
  */
 interface News {
     /** List of articles */
-    articles?: NewsArticle[];
+    Articles?: NewsArticle[];
     /** Total count */
-    total?: number;
+    Total?: number;
 }
 /**
  * Season calendar entry.
  */
 interface SeasonCalendarEntry {
     /** Season identifier */
-    seasonId?: string;
+    SeasonId?: string;
     /** Season name */
-    name?: DisplayString;
+    Name?: DisplayString;
     /** Start date (ISO 8601) */
-    startDate?: string;
+    StartDate?: string;
     /** End date (ISO 8601) */
-    endDate?: string;
+    EndDate?: string;
     /** CSR season identifier */
-    csrSeasonId?: string;
+    CsrSeasonId?: string;
 }
 /**
  * Season calendar.
  */
 interface SeasonCalendar {
     /** List of seasons */
-    seasons?: SeasonCalendarEntry[];
+    Seasons?: SeasonCalendarEntry[];
     /** Current season */
-    currentSeason?: string;
+    CurrentSeason?: string;
 }
 /**
  * Matches privacy settings.
  */
 interface MatchesPrivacy {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Privacy setting */
-    privacySetting?: string;
+    PrivacySetting?: string;
     /** Whether matches are public */
-    matchesPublic?: boolean;
+    MatchesPublic?: boolean;
 }
 /**
  * Player daily custom experience.
  */
 interface PlayerDailyCustomExperience {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Custom XP remaining */
-    remainingXp?: number;
+    RemainingXp?: number;
     /** Custom XP earned today */
-    earnedToday?: number;
+    EarnedToday?: number;
     /** Daily limit */
-    dailyLimit?: number;
+    DailyLimit?: number;
     /** Reset time (ISO 8601) */
-    resetTime?: string;
+    ResetTime?: string;
 }
 /**
  * Giveaway rewards.
  */
 interface PlayerGiveaways {
     /** List of pending giveaways */
-    giveaways?: GiveawayReward[];
+    Giveaways?: GiveawayReward[];
 }
 /**
  * Individual giveaway reward.
  */
 interface GiveawayReward {
     /** Giveaway identifier */
-    id?: string;
+    Id?: string;
     /** Title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Items included */
-    items?: InventoryAmount[];
+    Items?: InventoryAmount[];
     /** Claim deadline (ISO 8601) */
-    claimDeadline?: string;
+    ClaimDeadline?: string;
 }
 
 /**
@@ -1383,94 +1383,94 @@ declare class ConfigurationModule extends ModuleBase {
  */
 interface StoreOffering {
     /** Offering identifier */
-    offeringId?: string;
+    OfferingId?: string;
     /** Display title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    imagePath?: string;
+    ImagePath?: string;
     /** Price in each currency */
-    prices?: StorePrice[];
+    Prices?: StorePrice[];
     /** Items included */
-    includedItems?: InventoryAmount[];
+    IncludedItems?: InventoryAmount[];
     /** Offering type */
-    offeringType?: string;
+    OfferingType?: string;
     /** Start time (ISO 8601) */
-    startDate?: string;
+    StartDate?: string;
     /** End time (ISO 8601) */
-    endDate?: string;
+    EndDate?: string;
     /** Whether this is a bundle */
-    isBundle?: boolean;
+    IsBundle?: boolean;
     /** Whether player owns this */
-    isOwned?: boolean;
+    IsOwned?: boolean;
     /** Quality tier */
-    quality?: string;
+    Quality?: string;
 }
 /**
  * Price in a specific currency.
  */
 interface StorePrice {
     /** Currency identifier */
-    currencyId?: string;
+    CurrencyId?: string;
     /** Cost amount */
-    cost?: number;
+    Cost?: number;
     /** Original cost (before discount) */
-    originalCost?: number;
+    OriginalCost?: number;
     /** Discount percentage */
-    discountPercent?: number;
+    DiscountPercent?: number;
 }
 /**
  * Store item container (multiple offerings).
  */
 interface StoreItem {
     /** Store identifier */
-    storeId?: string;
+    StoreId?: string;
     /** Display name */
-    storeName?: string;
+    StoreName?: string;
     /** List of offerings */
-    offerings?: StoreOffering[];
+    Offerings?: StoreOffering[];
     /** Store refresh time (ISO 8601) */
-    refreshTime?: string;
+    RefreshTime?: string;
     /** Store expiration time (ISO 8601) */
-    expirationTime?: string;
+    ExpirationTime?: string;
 }
 /**
  * Active boost information.
  */
 interface ActiveBoost {
     /** Boost identifier */
-    boostId?: string;
+    BoostId?: string;
     /** Boost type */
-    boostType?: string;
+    BoostType?: string;
     /** Multiplier value */
-    multiplier?: number;
+    Multiplier?: number;
     /** Remaining uses */
-    remainingUses?: number;
+    RemainingUses?: number;
     /** Expiration time (ISO 8601) */
-    expirationTime?: string;
+    ExpirationTime?: string;
 }
 /**
  * Container for active boosts.
  */
 interface ActiveBoostsContainer {
     /** List of active boosts */
-    boosts?: ActiveBoost[];
+    Boosts?: ActiveBoost[];
 }
 /**
  * Reward snapshot.
  */
 interface RewardSnapshot {
     /** Reward identifier */
-    rewardId?: string;
+    RewardId?: string;
     /** Items awarded */
-    items?: InventoryAmount[];
+    Items?: InventoryAmount[];
     /** Currency awarded */
-    currencies?: CurrencyAmount[];
+    Currencies?: CurrencyAmount[];
     /** XP awarded */
-    xpAwarded?: number;
+    XpAwarded?: number;
     /** Claimed status */
-    claimed?: boolean;
+    Claimed?: boolean;
 }
 
 /**
@@ -1478,150 +1478,150 @@ interface RewardSnapshot {
  */
 interface CoreBase {
     /** Path to the core definition */
-    corePath?: string;
+    CorePath?: string;
     /** Whether this core is currently equipped */
-    isEquipped?: boolean;
+    IsEquipped?: boolean;
     /** Unique core identifier */
-    coreId?: string;
+    CoreId?: string;
     /** Type of core */
-    coreType?: string;
+    CoreType?: string;
     /** When the core was first acquired (ISO 8601) */
-    firstAcquiredDate?: string;
+    FirstAcquiredDate?: string;
 }
 /**
  * Base properties shared by all themes.
  */
 interface ThemeBase {
     /** When first modified (ISO 8601) */
-    firstModifiedDateUtc?: string;
+    FirstModifiedDateUtc?: string;
     /** When last modified (ISO 8601) */
-    lastModifiedDateUtc?: string;
+    LastModifiedDateUtc?: string;
     /** Whether this theme is currently equipped */
-    isEquipped?: boolean;
+    IsEquipped?: boolean;
     /** Whether this is the default theme */
-    isDefault?: boolean;
+    IsDefault?: boolean;
     /** Path to the theme definition */
-    themePath?: string;
+    ThemePath?: string;
 }
 /**
  * Armor core with themes.
  */
 interface ArmorCore extends CoreBase {
     /** Available themes for this core */
-    themes?: ArmorCoreTheme[];
+    Themes?: ArmorCoreTheme[];
 }
 /**
  * Armor core theme configuration.
  */
 interface ArmorCoreTheme extends ThemeBase {
     /** Helmet item path */
-    helmetPath?: string;
+    HelmetPath?: string;
     /** Visor item path */
-    visorPath?: string;
+    VisorPath?: string;
     /** Coating item path */
-    coatingPath?: string;
+    CoatingPath?: string;
     /** Left shoulder pad path */
-    leftShoulderPadPath?: string;
+    LeftShoulderPadPath?: string;
     /** Right shoulder pad path */
-    rightShoulderPadPath?: string;
+    RightShoulderPadPath?: string;
     /** Gloves path */
-    glovesPath?: string;
+    GlovesPath?: string;
     /** Chest attachment path */
-    chestAttachmentPath?: string;
+    ChestAttachmentPath?: string;
     /** Knee pads path */
-    kneePadsPath?: string;
+    KneePadsPath?: string;
     /** Wrist attachment path */
-    wristAttachmentPath?: string;
+    WristAttachmentPath?: string;
     /** Hip attachment path */
-    hipAttachmentPath?: string;
+    HipAttachmentPath?: string;
     /** Armor effect path */
-    armorEffectPath?: string;
+    ArmorEffectPath?: string;
     /** Mythic effect path */
-    mythicEffectPath?: string;
+    MythicEffectPath?: string;
 }
 /**
  * Weapon core with themes.
  */
 interface WeaponCore extends CoreBase {
     /** Available themes for this core */
-    themes?: WeaponCoreTheme[];
+    Themes?: WeaponCoreTheme[];
 }
 /**
  * Weapon core theme configuration.
  */
 interface WeaponCoreTheme extends ThemeBase {
     /** Coating item path */
-    coatingPath?: string;
+    CoatingPath?: string;
     /** Charm item path */
-    charmPath?: string;
+    CharmPath?: string;
     /** Death FX path */
-    deathFxPath?: string;
+    DeathFxPath?: string;
     /** Emblem path */
-    emblemPath?: string;
+    EmblemPath?: string;
 }
 /**
  * Vehicle core with themes.
  */
 interface VehicleCore extends CoreBase {
     /** Available themes for this core */
-    themes?: VehicleCoreTheme[];
+    Themes?: VehicleCoreTheme[];
 }
 /**
  * Vehicle core theme configuration.
  */
 interface VehicleCoreTheme extends ThemeBase {
     /** Coating item path */
-    coatingPath?: string;
+    CoatingPath?: string;
     /** Emblem path */
-    emblemPath?: string;
+    EmblemPath?: string;
     /** Vehicle effect path */
-    vehicleEffectPath?: string;
+    VehicleEffectPath?: string;
 }
 /**
  * AI core with themes.
  */
 interface AiCore extends CoreBase {
     /** Available themes for this core */
-    themes?: AiCoreTheme[];
+    Themes?: AiCoreTheme[];
 }
 /**
  * AI core theme configuration.
  */
 interface AiCoreTheme extends ThemeBase {
     /** AI model path */
-    modelPath?: string;
+    ModelPath?: string;
     /** Color primary path */
-    colorPrimaryPath?: string;
+    ColorPrimaryPath?: string;
     /** Color secondary path */
-    colorSecondaryPath?: string;
+    ColorSecondaryPath?: string;
 }
 /**
  * Collection of armor cores.
  */
 interface ArmorCoreCollection {
     /** List of armor cores */
-    armorCores?: ArmorCore[];
+    ArmorCores?: ArmorCore[];
 }
 /**
  * Collection of weapon cores.
  */
 interface WeaponCoreCollection {
     /** List of weapon cores */
-    weaponCores?: WeaponCore[];
+    WeaponCores?: WeaponCore[];
 }
 /**
  * Collection of vehicle cores.
  */
 interface VehicleCoreCollection {
     /** List of vehicle cores */
-    vehicleCores?: VehicleCore[];
+    VehicleCores?: VehicleCore[];
 }
 /**
  * Collection of AI cores.
  */
 interface AiCoreContainer {
     /** List of AI cores */
-    aiCores?: AiCore[];
+    AiCores?: AiCore[];
 }
 
 /**
@@ -1629,77 +1629,77 @@ interface AiCoreContainer {
  */
 interface SpartanBody {
     /** When last modified (ISO 8601) */
-    lastModifiedDateUtc?: string;
+    LastModifiedDateUtc?: string;
     /** Left arm prosthetic path */
-    leftArm?: string;
+    LeftArm?: string;
     /** Right arm prosthetic path */
-    rightArm?: string;
+    RightArm?: string;
     /** Left leg prosthetic path */
-    leftLeg?: string;
+    LeftLeg?: string;
     /** Right leg prosthetic path */
-    rightLeg?: string;
+    RightLeg?: string;
     /** Body type identifier */
-    bodyType?: string;
+    BodyType?: string;
     /** Voice number */
-    voice?: number;
+    Voice?: number;
     /** Voice path */
-    voicePath?: string;
+    VoicePath?: string;
 }
 /**
  * Player appearance configuration.
  */
 interface Appearance {
     /** When last modified (ISO 8601) */
-    lastModifiedDateUtc?: string;
+    LastModifiedDateUtc?: string;
     /** Service tag (4 characters) */
-    serviceTag?: string;
+    ServiceTag?: string;
     /** Intro gesture path */
-    introGesturePath?: string;
+    IntroGesturePath?: string;
     /** Outro gesture path */
-    outroGesturePath?: string;
+    OutroGesturePath?: string;
     /** Stance path */
-    stancePath?: string;
+    StancePath?: string;
     /** Emblem configuration */
-    emblem?: EmblemConfiguration;
+    Emblem?: EmblemConfiguration;
     /** Backdrop path */
-    backdropPath?: string;
+    BackdropPath?: string;
     /** Action pose path */
-    actionPosePath?: string;
+    ActionPosePath?: string;
 }
 /**
  * Emblem configuration.
  */
 interface EmblemConfiguration {
     /** Emblem path */
-    emblemPath?: string;
+    EmblemPath?: string;
     /** Emblem configuration ID */
-    configurationId?: number;
+    ConfigurationId?: number;
 }
 /**
  * Complete player customization data.
  */
 interface CustomizationData {
     /** Spartan body configuration */
-    spartanBody?: SpartanBody;
+    SpartanBody?: SpartanBody;
     /** Appearance settings */
-    appearance?: Appearance;
+    Appearance?: Appearance;
     /** Armor cores */
-    armorCores?: ArmorCoreCollection;
+    ArmorCores?: ArmorCoreCollection;
     /** Weapon cores */
-    weaponCores?: WeaponCoreCollection;
+    WeaponCores?: WeaponCoreCollection;
     /** Vehicle cores */
-    vehicleCores?: VehicleCoreCollection;
+    VehicleCores?: VehicleCoreCollection;
     /** AI cores */
-    aiCores?: AiCoreContainer;
+    AiCores?: AiCoreContainer;
 }
 /**
  * Appearance customization container.
  */
 interface AppearanceCustomization {
     /** Service tag */
-    serviceTag?: string;
+    ServiceTag?: string;
     /** Appearance configuration */
-    appearance?: Appearance;
+    Appearance?: Appearance;
 }
 
 /**
@@ -1707,95 +1707,95 @@ interface AppearanceCustomization {
  */
 interface Reward {
     /** Event XP awarded */
-    eventXp?: number;
+    EventXp?: number;
     /** Operation XP awarded */
-    operationXp?: number;
+    OperationXp?: number;
     /** Operation experience */
-    operationExperience?: number;
+    OperationExperience?: number;
     /** Soft experience (Spartan Points) */
-    softExperience?: number;
+    SoftExperience?: number;
     /** Inventory items rewarded */
-    inventoryRewards?: InventoryAmount[];
+    InventoryRewards?: InventoryAmount[];
     /** Inventory items */
-    inventoryItems?: unknown[];
+    InventoryItems?: unknown[];
     /** Tracking identifier */
-    trackingId?: string;
+    TrackingId?: string;
     /** Currencies awarded */
-    currencies?: unknown[];
+    Currencies?: unknown[];
     /** Reward track progression */
-    rewardTrackProgression?: RewardTrack[];
+    RewardTrackProgression?: RewardTrack[];
 }
 /**
  * Challenge definition.
  */
 interface Challenge {
     /** Challenge description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Difficulty level */
-    difficulty?: string;
+    Difficulty?: string;
     /** Challenge category */
-    category?: string;
+    Category?: string;
     /** Primary reward */
-    reward?: Reward;
+    Reward?: Reward;
     /** Secondary reward */
-    secondaryReward?: Reward;
+    SecondaryReward?: Reward;
     /** Threshold for success */
-    thresholdForSuccess?: number;
+    ThresholdForSuccess?: number;
     /** Challenge title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Type icon path */
-    typeIconPath?: string;
+    TypeIconPath?: string;
     /** Whether this is a user event challenge */
-    isUserEvent?: boolean;
+    IsUserEvent?: boolean;
     /** Challenge path */
-    path?: string;
+    Path?: string;
     /** Current progress */
-    progress?: number;
+    Progress?: number;
     /** Challenge identifier */
-    id?: string;
+    Id?: string;
     /** Whether the challenge can be rerolled */
-    canReroll?: boolean;
+    CanReroll?: boolean;
 }
 /**
  * Challenge deck (collection of challenges).
  */
 interface ChallengeDeck {
     /** Deck identifier */
-    id?: string;
+    Id?: string;
     /** Path to the deck */
-    path?: string;
+    Path?: string;
     /** Deck title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Challenges in this deck */
-    challenges?: Challenge[];
+    Challenges?: Challenge[];
 }
 /**
  * Challenge deck definition from CMS.
  */
 interface ChallengeDeckDefinition {
     /** Deck identifier */
-    id?: string;
+    Id?: string;
     /** Deck path */
-    path?: string;
+    Path?: string;
     /** Deck title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    imagePath?: string;
+    ImagePath?: string;
     /** Whether deck is visible */
-    isVisible?: boolean;
+    IsVisible?: boolean;
 }
 /**
  * Response for challenge decks query.
  */
 interface ChallengeDecksResponse {
     /** Active challenge decks */
-    activeDecks?: ChallengeDeck[];
+    ActiveDecks?: ChallengeDeck[];
     /** Upcoming decks */
-    upcomingDecks?: ChallengeDeck[];
+    UpcomingDecks?: ChallengeDeck[];
 }
 /**
  * Reward track progress measurement.
@@ -1836,36 +1836,36 @@ interface RewardTrack {
  */
 interface RewardTrackMetadata {
     /** Track identifier */
-    trackId?: string;
+    TrackId?: string;
     /** Track path */
-    path?: string;
+    Path?: string;
     /** Display title */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Description */
-    description?: DisplayString;
+    Description?: DisplayString;
     /** Image path */
-    imagePath?: string;
+    ImagePath?: string;
     /** Track type */
-    type?: string;
+    Type?: string;
     /** Start date (ISO 8601) */
-    startDate?: string;
+    StartDate?: string;
     /** End date (ISO 8601) */
-    endDate?: string;
+    EndDate?: string;
 }
 /**
  * Operation reward track snapshot.
  */
 interface OperationRewardTrackSnapshot {
     /** Track identifier */
-    trackId?: string;
+    TrackId?: string;
     /** Current rank */
-    rank?: number;
+    Rank?: number;
     /** Current XP */
-    xp?: number;
+    Xp?: number;
     /** Total XP earned */
-    totalXpEarned?: number;
+    TotalXpEarned?: number;
     /** Premium status */
-    isPremium?: boolean;
+    IsPremium?: boolean;
 }
 
 /**
@@ -1873,114 +1873,114 @@ interface OperationRewardTrackSnapshot {
  */
 interface CareerRank {
     /** Rank number */
-    rank?: number;
+    Rank?: number;
     /** Title of the rank */
-    title?: DisplayString;
+    Title?: DisplayString;
     /** Subtitle */
-    subtitle?: DisplayString;
+    Subtitle?: DisplayString;
     /** Large icon path */
-    largeIconPath?: string;
+    LargeIconPath?: string;
     /** Small icon path */
-    smallIconPath?: string;
+    SmallIconPath?: string;
     /** Adornment icon path */
-    adornmentIconPath?: string;
+    AdornmentIconPath?: string;
     /** XP required to reach this rank */
-    xpRequired?: number;
+    XpRequired?: number;
     /** Cumulative XP at this rank */
-    cumulativeXp?: number;
+    CumulativeXp?: number;
     /** Grade within the rank */
-    grade?: number;
+    Grade?: number;
     /** Tier within the rank */
-    tier?: number;
+    Tier?: number;
 }
 /**
  * Container for career ranks.
  */
 interface CareerTrackContainer {
     /** Career path identifier */
-    careerPathId?: string;
+    CareerPathId?: string;
     /** List of career ranks */
-    ranks?: CareerRank[];
+    Ranks?: CareerRank[];
     /** Maximum rank */
-    maxRank?: number;
+    MaxRank?: number;
 }
 /**
  * Player's career rank result.
  */
 interface PlayerCareerRankResult {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Current career rank */
-    currentRank?: number;
+    CurrentRank?: number;
     /** Current XP */
-    currentXp?: number;
+    CurrentXp?: number;
     /** XP to next rank */
-    xpToNextRank?: number;
+    XpToNextRank?: number;
     /** Result code */
-    resultCode?: number;
+    ResultCode?: number;
 }
 /**
  * Container for player career rank results.
  */
 interface RewardTrackResultContainer {
     /** Career path identifier */
-    careerPathId?: string;
+    CareerPathId?: string;
     /** Results for each player */
-    value?: PlayerCareerRankResult[];
+    Value?: PlayerCareerRankResult[];
 }
 /**
  * Match progression (post-game rewards).
  */
 interface MatchProgression {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Match identifier */
-    matchId?: string;
+    MatchId?: string;
     /** Challenges progressed */
-    challengeProgress?: ChallengeProgress[];
+    ChallengeProgress?: ChallengeProgress[];
     /** XP earned breakdown */
-    xpBreakdown?: XpBreakdown;
+    XpBreakdown?: XpBreakdown;
     /** Career rank progression */
-    careerRankProgress?: CareerRankProgress;
+    CareerRankProgress?: CareerRankProgress;
 }
 /**
  * Challenge progress from a match.
  */
 interface ChallengeProgress {
     /** Challenge identifier */
-    challengeId?: string;
+    ChallengeId?: string;
     /** Progress made */
-    progress?: number;
+    Progress?: number;
     /** Whether challenge was completed */
-    completed?: boolean;
+    Completed?: boolean;
 }
 /**
  * XP breakdown from a match.
  */
 interface XpBreakdown {
     /** Base XP from match */
-    matchXp?: number;
+    MatchXp?: number;
     /** XP from medals */
-    medalXp?: number;
+    MedalXp?: number;
     /** XP from challenges */
-    challengeXp?: number;
+    ChallengeXp?: number;
     /** Boost XP */
-    boostXp?: number;
+    BoostXp?: number;
     /** Total XP */
-    totalXp?: number;
+    TotalXp?: number;
 }
 /**
  * Career rank progress from a match.
  */
 interface CareerRankProgress {
     /** Rank before match */
-    previousRank?: number;
+    PreviousRank?: number;
     /** Rank after match */
-    currentRank?: number;
+    CurrentRank?: number;
     /** XP earned */
-    xpEarned?: number;
+    XpEarned?: number;
     /** Whether player ranked up */
-    rankedUp?: boolean;
+    RankedUp?: boolean;
 }
 
 /**
@@ -2022,7 +2022,7 @@ declare class EconomyModule extends ModuleBase {
      */
     getVirtualCurrencyBalances(player: string): Promise<HaloApiResult<CurrencySnapshot>>;
     /**
-     * Post a currency transaction.
+     * Get a currency transaction.
      *
      * @param player - Player's numeric XUID
      * @param currencyId - Currency identifier
@@ -2254,9 +2254,10 @@ declare class EconomyModule extends ModuleBase {
      * Get operation progress for a player.
      *
      * @param player - Player's numeric XUID
+     * @param flightId - Flight/clearance ID
      * @returns Operation reward track snapshot
      */
-    getPlayerOperations(player: string): Promise<HaloApiResult<OperationRewardTrackSnapshot>>;
+    getPlayerOperations(player: string, flightId?: string): Promise<HaloApiResult<OperationRewardTrackSnapshot>>;
     /**
      * Get career rank for a player.
      *
@@ -2458,12 +2459,6 @@ declare class GameCmsModule extends ModuleBase {
      * @returns News collection
      */
     getNews(filePath: string): Promise<HaloApiResult<News>>;
-    /**
-     * Get academy star definitions.
-     *
-     * @returns Star definitions
-     */
-    getAcademyStarDefinitions(): Promise<HaloApiResult<AcademyStarDefinitions>>;
     /**
      * Get an image file from the CMS.
      *
@@ -2659,7 +2654,7 @@ declare class LobbyModule extends ModuleBase {
      * @param presenceRequest - Presence request container
      * @returns Presence results
      */
-    presence(presenceRequest: LobbyPresenceRequestContainer): Promise<HaloApiResult<LobbyPresenceContainer>>;
+    presence(): Promise<HaloApiResult<LobbyPresenceContainer>>;
     /**
      * Get a third-party join handle for a lobby.
      *
@@ -2759,73 +2754,73 @@ declare class SettingsModule extends ModuleBase {
  */
 interface Csr {
     /** Current CSR value */
-    value?: number;
+    Value?: number;
     /** Measurement matches remaining before placement */
-    measurementMatchesRemaining?: number;
+    MeasurementMatchesRemaining?: number;
     /** Current tier name (e.g., "Diamond", "Onyx") */
-    tier?: string;
+    Tier?: string;
     /** CSR value at start of current tier */
-    tierStart?: number;
+    TierStart?: number;
     /** Current sub-tier within the tier (1-6) */
-    subTier?: number;
+    SubTier?: number;
     /** Next tier name */
-    nextTier?: string;
+    NextTier?: string;
     /** CSR value at start of next tier */
-    nextTierStart?: number;
+    NextTierStart?: number;
     /** Next sub-tier */
-    nextSubTier?: number;
+    NextSubTier?: number;
     /** Initial number of placement matches required */
-    initialMeasurementMatches?: number;
+    InitialMeasurementMatches?: number;
     /** Initial demotion protection matches */
-    initialDemotionProtectionMatches?: number;
+    InitialDemotionProtectionMatches?: number;
     /** Remaining demotion protection matches */
-    demotionProtectionMatchesRemaining?: number;
+    DemotionProtectionMatchesRemaining?: number;
 }
 /**
  * Match skill information for a single player.
  */
 interface PlayerMatchSkill {
     /** Player identifier */
-    id?: string;
+    Id?: string;
     /** CSR before the match */
-    preMatchCsr?: Csr;
+    PreMatchCsr?: Csr;
     /** CSR after the match */
-    postMatchCsr?: Csr;
+    PostMatchCsr?: Csr;
     /** Expected CSR at ranking */
-    expectedRankCsr?: Csr;
+    ExpectedRankCsr?: Csr;
     /** Result code */
-    resultCode?: number;
+    ResultCode?: number;
 }
 /**
  * Container for match skill results.
  */
 interface MatchSkillInfo {
     /** Match identifier */
-    matchId?: string;
+    MatchId?: string;
     /** Skill results for each player */
-    value?: PlayerMatchSkill[];
+    Value?: PlayerMatchSkill[];
 }
 /**
  * Playlist CSR result for a single player.
  */
 interface PlayerPlaylistCsr {
     /** Player identifier */
-    id?: string;
+    Id?: string;
     /** Current CSR for this playlist */
-    csr?: Csr;
+    Csr?: Csr;
     /** Result code */
-    resultCode?: number;
+    ResultCode?: number;
 }
 /**
  * Container for playlist CSR results.
  */
 interface PlaylistCsrResultContainer {
     /** Playlist identifier */
-    playlistId?: string;
+    PlaylistId?: string;
     /** Season identifier (if applicable) */
-    seasonId?: string;
+    SeasonId?: string;
     /** CSR results for each player */
-    value?: PlayerPlaylistCsr[];
+    Value?: PlayerPlaylistCsr[];
 }
 
 /**
@@ -2908,38 +2903,38 @@ type LifecycleMode = (typeof LifecycleMode)[keyof typeof LifecycleMode];
  */
 interface GenericAsset {
     /** Unique asset identifier */
-    assetId?: string;
+    AssetId?: string;
     /** Version identifier */
-    versionId?: string;
+    VersionId?: string;
     /** Combined asset version identifier */
-    assetVersionId?: string;
+    AssetVersionId?: string;
     /** Display name */
-    publicName?: string;
+    PublicName?: string;
 }
 /**
  * UGC game variant information in match context.
  */
 interface UgcGameVariant {
     /** Asset identifier */
-    assetId?: string;
+    AssetId?: string;
     /** Version identifier */
-    versionId?: string;
+    VersionId?: string;
     /** Display name */
-    publicName?: string;
+    PublicName?: string;
 }
 /**
  * Playlist experience tracking.
  */
 interface PlaylistExperience {
     /** Experience value */
-    value?: number;
+    Value?: number;
 }
 /**
  * Gameplay interaction type.
  */
 interface GameplayInteraction {
     /** Interaction type identifier */
-    value?: number;
+    Value?: number;
 }
 /**
  * General information about a match.
@@ -2948,39 +2943,39 @@ interface GameplayInteraction {
  */
 interface MatchInfo {
     /** Match start time (ISO 8601) */
-    startTime?: string;
+    StartTime?: string;
     /** Match end time (ISO 8601) */
-    endTime?: string;
+    EndTime?: string;
     /** Match duration as ISO 8601 duration string (e.g., "PT10M30S") */
-    duration?: string;
+    Duration?: string;
     /** Lifecycle mode (matchmade, custom, local) */
-    lifecycleMode?: LifecycleMode;
+    LifecycleMode?: LifecycleMode;
     /** Game variant category */
-    gameVariantCategory?: number;
+    GameVariantCategory?: number;
     /** Map/level identifier */
-    levelId?: string;
+    LevelId?: string;
     /** Map variant information */
-    mapVariant?: GenericAsset;
+    MapVariant?: GenericAsset;
     /** UGC game variant (for custom games) */
-    ugcGameVariant?: UgcGameVariant;
+    UgcGameVariant?: UgcGameVariant;
     /** Clearance ID used for the match */
-    clearanceId?: string;
+    ClearanceId?: string;
     /** Playlist information */
-    playlist?: GenericAsset;
+    Playlist?: GenericAsset;
     /** Playlist experience info */
-    playlistExperience?: PlaylistExperience;
+    PlaylistExperience?: PlaylistExperience;
     /** Map-mode pair info */
-    playlistMapModePair?: GenericAsset;
+    PlaylistMapModePair?: GenericAsset;
     /** Season identifier */
-    seasonId?: string;
+    SeasonId?: string;
     /** Playable duration */
-    playableDuration?: string;
+    PlayableDuration?: string;
     /** Whether teams were enabled */
-    teamsEnabled?: boolean;
+    TeamsEnabled?: boolean;
     /** Whether team scoring was enabled */
-    teamScoringEnabled?: boolean;
+    TeamScoringEnabled?: boolean;
     /** Gameplay interaction type */
-    gameplayInteraction?: GameplayInteraction;
+    GameplayInteraction?: GameplayInteraction;
 }
 
 /**
@@ -2988,305 +2983,305 @@ interface MatchInfo {
  */
 interface CoreStats {
     /** Total score earned */
-    score?: number;
+    Score?: number;
     /** Personal score (individual contribution) */
-    personalScore?: number;
+    PersonalScore?: number;
     /** Number of rounds won */
-    roundsWon?: number;
+    RoundsWon?: number;
     /** Number of rounds lost */
-    roundsLost?: number;
+    RoundsLost?: number;
     /** Number of rounds tied */
-    roundsTied?: number;
+    RoundsTied?: number;
     /** Total kills */
-    kills?: number;
+    Kills?: number;
     /** Total deaths */
-    deaths?: number;
+    Deaths?: number;
     /** Total assists */
-    assists?: number;
+    Assists?: number;
     /** Kill/Death/Assist ratio */
-    kda?: number;
+    Kda?: number;
     /** Total suicides */
-    suicides?: number;
+    Suicides?: number;
     /** Total betrayals (team kills) */
-    betrayals?: number;
+    Betrayals?: number;
     /** Average life duration in seconds */
-    averageLifeDuration?: string;
+    AverageLifeDuration?: string;
     /** Grenade kills */
-    grenadeKills?: number;
+    GrenadeKills?: number;
     /** Headshot kills */
-    headshotKills?: number;
+    HeadshotKills?: number;
     /** Melee kills */
-    meleeKills?: number;
+    MeleeKills?: number;
     /** Power weapon kills */
-    powerWeaponKills?: number;
+    PowerWeaponKills?: number;
     /** Shots fired */
-    shotsFired?: number;
+    ShotsFired?: number;
     /** Shots hit */
-    shotsHit?: number;
+    ShotsHit?: number;
     /** Accuracy percentage */
-    accuracy?: number;
+    Accuracy?: number;
     /** Damage dealt */
-    damageDealt?: number;
+    DamageDealt?: number;
     /** Damage taken */
-    damageTaken?: number;
+    DamageTaken?: number;
     /** Callout assists */
-    calloutAssists?: number;
+    CalloutAssists?: number;
     /** Vehicle destroys */
-    vehicleDestroys?: number;
+    VehicleDestroys?: number;
     /** Driver assists */
-    driverAssists?: number;
+    DriverAssists?: number;
     /** Hijacks */
-    hijacks?: number;
+    Hijacks?: number;
     /** EMP assists */
-    empAssists?: number;
+    EmpAssists?: number;
     /** Maximum killing spree */
-    maxKillingSpree?: number;
+    MaxKillingSpree?: number;
     /** Medals earned */
-    medals?: MedalCount[];
+    Medals?: MedalCount[];
     /** Personal scores breakdown */
-    personalScores?: PersonalScoreEntry[];
+    PersonalScores?: PersonalScoreEntry[];
     /** Deprecated Spartan Rank */
-    deprecatedDamageDealt?: number;
+    DeprecatedDamageDealt?: number;
     /** Deprecated Spartan Rank */
-    deprecatedDamageTaken?: number;
+    DeprecatedDamageTaken?: number;
     /** Spawns */
-    spawns?: number;
+    Spawns?: number;
     /** Objectives completed */
-    objectivesCompleted?: number;
+    ObjectivesCompleted?: number;
 }
 /**
  * Medal count entry.
  */
 interface MedalCount {
     /** Medal name identifier */
-    nameId?: number;
+    NameId?: number;
     /** Number of times earned */
-    count?: number;
+    Count?: number;
     /** Total personal score from this medal */
-    totalPersonalScoreAwarded?: number;
+    TotalPersonalScoreAwarded?: number;
 }
 /**
  * Personal score breakdown entry.
  */
 interface PersonalScoreEntry {
     /** Score type name identifier */
-    nameId?: number;
+    NameId?: number;
     /** Number of times earned */
-    count?: number;
+    Count?: number;
     /** Total score from this type */
-    totalPersonalScoreAwarded?: number;
+    TotalPersonalScoreAwarded?: number;
 }
 /**
  * Bomb game mode stats (Assault).
  */
 interface BombStats {
     /** Bombs planted */
-    bombsPlanted?: number;
+    BombsPlanted?: number;
     /** Bombs defused */
-    bombsDefused?: number;
+    BombsDefused?: number;
     /** Bomb carriers killed */
-    bombCarriersKilled?: number;
+    BombCarriersKilled?: number;
     /** Time as bomb carrier */
-    timeAsBombCarrier?: string;
+    TimeAsBombCarrier?: string;
 }
 /**
  * Capture the Flag game mode stats.
  */
 interface CaptureTheFlagStats {
     /** Flag captures */
-    flagCaptures?: number;
+    FlagCaptures?: number;
     /** Flag capture assists */
-    flagCaptureAssists?: number;
+    FlagCaptureAssists?: number;
     /** Flag carriers killed */
-    flagCarriersKilled?: number;
+    FlagCarriersKilled?: number;
     /** Flag grabs */
-    flagGrabs?: number;
+    FlagGrabs?: number;
     /** Flags returned */
-    flagsReturned?: number;
+    FlagsReturned?: number;
     /** Flags stolen */
-    flagsStolen?: number;
+    FlagsStolen?: number;
     /** Time as flag carrier */
-    timeAsFlagCarrier?: string;
+    TimeAsFlagCarrier?: string;
     /** Kills as flag carrier */
-    killsAsFlagCarrier?: number;
+    KillsAsFlagCarrier?: number;
 }
 /**
  * Elimination game mode stats.
  */
 interface EliminationStats {
     /** Allies revived */
-    alliesRevived?: number;
+    AlliesRevived?: number;
     /** Revives denied */
-    revivesDenied?: number;
+    RevivesDenied?: number;
     /** Eliminations */
-    eliminations?: number;
+    Eliminations?: number;
     /** Elimination assists */
-    eliminationAssists?: number;
+    EliminationAssists?: number;
     /** Times revived */
-    timesRevived?: number;
+    TimesRevived?: number;
     /** Rounds survived */
-    roundsSurvived?: number;
+    RoundsSurvived?: number;
     /** Executions */
-    executions?: number;
+    Executions?: number;
     /** Last spartans standing */
-    lastSpartansStanding?: number;
+    LastSpartansStanding?: number;
 }
 /**
  * Extraction game mode stats.
  */
 interface ExtractionStats {
     /** Extractions initiated */
-    extractionInitiated?: number;
+    ExtractionInitiated?: number;
     /** Extractions completed */
-    extractionCompleted?: number;
+    ExtractionCompleted?: number;
     /** Extractions converted */
-    extractionConverted?: number;
+    ExtractionConverted?: number;
     /** Extractions denied */
-    extractionDenied?: number;
+    ExtractionDenied?: number;
     /** Successful extractions */
-    successfulExtractions?: number;
+    SuccessfulExtractions?: number;
     /** Seconds converting */
-    secondsConverting?: number;
+    SecondsConverting?: number;
 }
 /**
  * Infection game mode stats.
  */
 interface InfectionStats {
     /** Infected killed */
-    infectedKilled?: number;
+    InfectedKilled?: number;
     /** Spartans infected */
-    spartansInfected?: number;
+    SpartansInfected?: number;
     /** Spartans infected as last spartan */
-    spartansInfectedAsLastSpartan?: number;
+    SpartansInfectedAsLastSpartan?: number;
     /** Infected killed as last spartan */
-    infectedKilledAsLastSpartan?: number;
+    InfectedKilledAsLastSpartan?: number;
     /** Time as last spartan */
-    timeAsLastSpartan?: string;
+    TimeAsLastSpartan?: string;
     /** Time as survivor */
-    timeAsSurvivor?: string;
+    TimeAsSurvivor?: string;
     /** Rounds as survivor */
-    roundsAsSurvivor?: number;
+    RoundsAsSurvivor?: number;
     /** Rounds as infected */
-    roundsAsInfected?: number;
+    RoundsAsInfected?: number;
     /** Rounds survived as spartan */
-    roundsSurvivedAsSpartan?: number;
+    RoundsSurvivedAsSpartan?: number;
     /** Rounds survived as last spartan */
-    roundsSurvivedAsLastSpartan?: number;
+    RoundsSurvivedAsLastSpartan?: number;
     /** Kills as last spartan */
-    killsAsLastSpartan?: number;
+    KillsAsLastSpartan?: number;
     /** Alpha infections */
-    alphaInfections?: number;
+    AlphaInfections?: number;
 }
 /**
  * Oddball game mode stats.
  */
 interface OddballStats {
     /** Time with ball */
-    timeWithBall?: string;
+    TimeWithBall?: string;
     /** Ball carriers killed */
-    ballCarriersKilled?: number;
+    BallCarriersKilled?: number;
     /** Kills as ball carrier */
-    killsAsBallCarrier?: number;
+    KillsAsBallCarrier?: number;
     /** Ball grabs */
-    ballGrabs?: number;
+    BallGrabs?: number;
     /** Longest time with ball */
-    longestTimeWithBall?: string;
+    LongestTimeWithBall?: string;
 }
 /**
  * Zones game mode stats (Land Grab, Strongholds, etc.).
  */
 interface ZonesStats {
     /** Zones captured */
-    zoneCaptures?: number;
+    ZoneCaptures?: number;
     /** Zone defensive kills */
-    zoneDefensiveKills?: number;
+    ZoneDefensiveKills?: number;
     /** Zone offensive kills */
-    zoneOffensiveKills?: number;
+    ZoneOffensiveKills?: number;
     /** Zone securing kills */
-    zoneSecuringKills?: number;
+    ZoneSecuringKills?: number;
     /** Zone occupation time */
-    zoneOccupationTime?: string;
+    ZoneOccupationTime?: string;
     /** Zones scored */
-    zonesScored?: number;
+    ZonesScored?: number;
     /** Zone scoring ticks */
-    zoneScoringTicks?: number;
+    ZoneScoringTicks?: number;
 }
 /**
  * Stockpile game mode stats.
  */
 interface StockpileStats {
     /** Power seeds deposited */
-    powerSeedsDeposited?: number;
+    PowerSeedsDeposited?: number;
     /** Power seeds stolen */
-    powerSeedsStolen?: number;
+    PowerSeedsStolen?: number;
     /** Kill as power seed carrier */
-    killsAsPowerSeedCarrier?: number;
+    KillsAsPowerSeedCarrier?: number;
     /** Power seed carriers killed */
-    powerSeedCarriersKilled?: number;
+    PowerSeedCarriersKilled?: number;
     /** Time as power seed carrier */
-    timeAsPowerSeedCarrier?: string;
+    TimeAsPowerSeedCarrier?: string;
 }
 /**
  * VIP game mode stats.
  */
 interface VipStats {
     /** VIP kills */
-    vipKills?: number;
+    VipKills?: number;
     /** Kills as VIP */
-    killsAsVip?: number;
+    KillsAsVip?: number;
     /** Time as VIP */
-    timeAsVip?: string;
+    TimeAsVip?: string;
 }
 /**
  * PvE (Firefight) stats.
  */
 interface PveStats {
     /** Boss kills */
-    bossKills?: number;
+    BossKills?: number;
     /** Emplacement kills */
-    emplacementKills?: number;
+    EmplacementKills?: number;
     /** Enemy vehicle kills */
-    enemyVehicleKills?: number;
+    EnemyVehicleKills?: number;
     /** Wave survived */
-    wavesSurvived?: number;
+    WavesSurvived?: number;
     /** Last spartan standing */
-    lastSpartanStanding?: boolean;
+    LastSpartanStanding?: boolean;
 }
 /**
  * PvP stats (used in some game modes).
  */
 interface PvpStats {
     /** Spartan kills */
-    spartanKills?: number;
+    SpartanKills?: number;
 }
 /**
  * Container for all mode-specific stats.
  */
 interface Stats {
     /** Core stats (applies to all modes) */
-    coreStats?: CoreStats;
+    CoreStats?: CoreStats;
     /** Bomb stats */
-    bombStats?: BombStats;
+    BombStats?: BombStats;
     /** CTF stats */
-    captureTheFlagStats?: CaptureTheFlagStats;
+    CaptureTheFlagStats?: CaptureTheFlagStats;
     /** Elimination stats */
-    eliminationStats?: EliminationStats;
+    EliminationStats?: EliminationStats;
     /** Extraction stats */
-    extractionStats?: ExtractionStats;
+    ExtractionStats?: ExtractionStats;
     /** Infection stats */
-    infectionStats?: InfectionStats;
+    InfectionStats?: InfectionStats;
     /** Oddball stats */
-    oddballStats?: OddballStats;
+    OddballStats?: OddballStats;
     /** Zones stats */
-    zonesStats?: ZonesStats;
+    ZonesStats?: ZonesStats;
     /** Stockpile stats */
-    stockpileStats?: StockpileStats;
+    StockpileStats?: StockpileStats;
     /** VIP stats */
-    vipStats?: VipStats;
+    VipStats?: VipStats;
     /** PvE stats */
-    pveStats?: PveStats;
+    PveStats?: PveStats;
     /** PvP stats */
-    pvpStats?: PvpStats;
+    PvpStats?: PvpStats;
 }
 
 /**
@@ -3326,77 +3321,77 @@ type Outcome = (typeof Outcome)[keyof typeof Outcome];
  */
 interface BotAttributes {
     /** Bot difficulty */
-    difficulty?: number;
+    Difficulty?: number;
     /** Bot skill level */
-    skillLevel?: number;
+    SkillLevel?: number;
 }
 /**
  * Participation information for a player.
  */
 interface ParticipationInfo {
     /** Time played (ISO 8601 duration) */
-    timePlayed?: string;
+    TimePlayed?: string;
     /** Whether player was present at start */
-    presentAtStart?: boolean;
+    PresentAtStart?: boolean;
     /** Whether player was present at end */
-    presentAtEnd?: boolean;
+    PresentAtEnd?: boolean;
     /** Whether player joined mid-match */
-    joinedInProgress?: boolean;
+    JoinedInProgress?: boolean;
     /** When player joined (ISO 8601) */
-    joinedAt?: string;
+    JoinedAt?: string;
     /** When player left (ISO 8601, if applicable) */
-    leftAt?: string;
+    LeftAt?: string;
     /** First joined time (ISO 8601) */
-    firstJoinedTime?: string;
+    FirstJoinedTime?: string;
     /** Last joined time (ISO 8601) */
-    lastJoinedTime?: string;
+    LastJoinedTime?: string;
     /** Whether player left before completion */
-    leftInProgress?: boolean;
+    LeftInProgress?: boolean;
     /** Confirmed participation */
-    confirmedParticipation?: boolean;
+    ConfirmedParticipation?: boolean;
 }
 /**
  * Player's stats for a specific team.
  */
 interface PlayerTeamStat {
     /** Team identifier */
-    teamId?: number;
+    TeamId?: number;
     /** Stats for this team */
-    stats?: Stats;
+    Stats?: Stats;
 }
 /**
  * Player information from a match.
  */
 interface Player {
     /** Player identifier (format: "xuid(XUID)") */
-    playerId?: string;
+    PlayerId?: string;
     /** Type of player (Human or Bot) */
-    playerType?: PlayerType;
+    PlayerType?: PlayerType;
     /** Bot attributes (only if playerType is Bot) */
-    botAttributes?: BotAttributes;
+    BotAttributes?: BotAttributes;
     /** Last team the player was on */
-    lastTeamId?: number;
+    LastTeamId?: number;
     /** Match outcome for this player */
-    outcome?: Outcome;
+    Outcome?: Outcome;
     /** Final rank/placement */
-    rank?: number;
+    Rank?: number;
     /** Participation details */
-    participationInfo?: ParticipationInfo;
+    ParticipationInfo?: ParticipationInfo;
     /** Stats broken down by team */
-    playerTeamStats?: PlayerTeamStat[];
+    PlayerTeamStats?: PlayerTeamStat[];
 }
 /**
  * Team information from a match.
  */
 interface Team {
     /** Team identifier */
-    teamId?: number;
+    TeamId?: number;
     /** Match outcome for this team */
-    outcome?: number;
+    Outcome?: number;
     /** Final rank/placement */
-    rank?: number;
+    Rank?: number;
     /** Team stats */
-    stats?: Stats;
+    Stats?: Stats;
 }
 
 /**
@@ -3407,13 +3402,13 @@ interface Team {
  */
 interface MatchStats {
     /** Unique match identifier */
-    matchId?: string;
+    MatchId?: string;
     /** General match information */
-    matchInfo?: MatchInfo;
+    MatchInfo?: MatchInfo;
     /** List of teams in the match */
-    teams?: Team[];
+    Teams?: Team[];
     /** List of players in the match */
-    players?: Player[];
+    Players?: Player[];
 }
 
 /**
@@ -3421,56 +3416,56 @@ interface MatchStats {
  */
 interface MatchLinks {
     /** Link to next page of results */
-    next?: string;
+    Next?: string;
     /** Link to previous page of results */
-    prev?: string;
+    Prev?: string;
 }
 /**
  * Individual match record in match history.
  */
 interface PlayerMatchHistoryRecord {
     /** Unique match identifier */
-    matchId?: string;
+    MatchId?: string;
     /** Match information */
-    matchInfo?: MatchInfo;
+    MatchInfo?: MatchInfo;
     /** Last team the player was on */
-    lastTeamId?: number;
+    LastTeamId?: number;
     /** Match outcome for this player */
-    outcome?: number;
+    Outcome?: number;
     /** Final rank/placement */
-    rank?: number;
+    Rank?: number;
     /** Whether player was present at end */
-    presentAtEnd?: boolean;
+    PresentAtEnd?: boolean;
     /** Player-specific data for this match */
-    player?: Player;
+    Player?: Player;
 }
 /**
  * Response container for match history queries.
  */
 interface MatchHistoryResponse {
     /** Starting index of results */
-    start?: number;
+    Start?: number;
     /** Number of results requested */
-    count?: number;
+    Count?: number;
     /** Number of results returned */
-    resultCount?: number;
+    ResultCount?: number;
     /** List of match records */
-    results?: PlayerMatchHistoryRecord[];
+    Results?: PlayerMatchHistoryRecord[];
     /** Pagination links */
-    links?: MatchLinks;
+    Links?: MatchLinks;
 }
 /**
  * Player match count summary.
  */
 interface PlayerMatchCount {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Total custom game count */
-    customMatchesPlayedCount?: number;
+    CustomMatchesPlayedCount?: number;
     /** Total matchmade games count */
-    matchmadeMatchesPlayedCount?: number;
+    MatchmadeMatchesPlayedCount?: number;
     /** Total local games count */
-    localMatchesPlayedCount?: number;
+    LocalMatchesPlayedCount?: number;
 }
 
 /**
@@ -3478,71 +3473,71 @@ interface PlayerMatchCount {
  */
 interface ServiceRecordSubqueries {
     /** Seasonal breakdown of stats */
-    seasons?: SeasonServiceRecord[];
+    Seasons?: SeasonServiceRecord[];
     /** Map breakdown of stats */
-    maps?: MapServiceRecord[];
+    Maps?: MapServiceRecord[];
     /** Game variant breakdown */
-    gameVariants?: GameVariantServiceRecord[];
+    GameVariants?: GameVariantServiceRecord[];
     /** Playlist breakdown */
-    playlists?: PlaylistServiceRecord[];
+    Playlists?: PlaylistServiceRecord[];
 }
 /**
  * Season-specific service record.
  */
 interface SeasonServiceRecord {
     /** Season identifier */
-    seasonId?: string;
+    SeasonId?: string;
     /** Stats for this season */
-    stats?: Stats;
+    Stats?: Stats;
 }
 /**
  * Map-specific service record.
  */
 interface MapServiceRecord {
     /** Map asset identifier */
-    assetId?: string;
+    AssetId?: string;
     /** Stats for this map */
-    stats?: Stats;
+    Stats?: Stats;
 }
 /**
  * Game variant-specific service record.
  */
 interface GameVariantServiceRecord {
     /** Game variant category */
-    gameVariantCategory?: number;
+    GameVariantCategory?: number;
     /** Stats for this game variant */
-    stats?: Stats;
+    Stats?: Stats;
 }
 /**
  * Playlist-specific service record.
  */
 interface PlaylistServiceRecord {
     /** Playlist asset identifier */
-    assetId?: string;
+    AssetId?: string;
     /** Stats for this playlist */
-    stats?: Stats;
+    Stats?: Stats;
 }
 /**
  * Time played breakdown.
  */
 interface TimePlayed {
     /** Total seconds played */
-    seconds?: number;
+    Seconds?: number;
     /** Human-readable duration */
-    human?: string;
+    Human?: string;
 }
 /**
  * Win-loss record.
  */
 interface WinLossRecord {
     /** Number of wins */
-    wins?: number;
+    Wins?: number;
     /** Number of losses */
-    losses?: number;
+    Losses?: number;
     /** Number of ties */
-    ties?: number;
+    Ties?: number;
     /** Number of games left early */
-    left?: number;
+    Left?: number;
 }
 /**
  * Player service record (career stats).
@@ -3551,17 +3546,17 @@ interface WinLossRecord {
  */
 interface PlayerServiceRecord {
     /** Player identifier */
-    playerId?: string;
+    PlayerId?: string;
     /** Core aggregate stats */
-    stats?: Stats;
+    Stats?: Stats;
     /** Time played breakdown */
-    timePlayed?: TimePlayed;
+    TimePlayed?: TimePlayed;
     /** Win/loss/tie record */
-    winLossRecord?: WinLossRecord;
+    WinLossRecord?: WinLossRecord;
     /** Matches played */
-    matchesPlayed?: number;
+    MatchesPlayed?: number;
     /** Subquery breakdowns (by season, map, etc.) */
-    subqueries?: ServiceRecordSubqueries;
+    Subqueries?: ServiceRecordSubqueries;
 }
 
 /**
@@ -3662,15 +3657,6 @@ declare class StatsModule extends ModuleBase {
     getPlayerDailyCustomExperience(player: string): Promise<HaloApiResult<PlayerDailyCustomExperience>>;
 }
 
-/**
- * Text moderation key response.
- */
-interface ModerationKey {
-    /** The moderation key */
-    key?: string;
-    /** Expiration time (ISO 8601) */
-    expiresAt?: string;
-}
 /**
  * Signing key for moderation proofs.
  */
@@ -3700,9 +3686,6 @@ interface ModerationProofKeys {
  *
  * @example
  * ```typescript
- * // Get moderation key
- * const key = await client.textModeration.getModerationKey();
- *
  * // Get all signing keys
  * const keys = await client.textModeration.getSigningKeys();
  *
@@ -3712,12 +3695,6 @@ interface ModerationProofKeys {
  */
 declare class TextModerationModule extends ModuleBase {
     constructor(client: ClientBase);
-    /**
-     * Get a moderation key for text validation.
-     *
-     * @returns Moderation key
-     */
-    getModerationKey(): Promise<HaloApiResult<ModerationKey>>;
     /**
      * Get a specific moderation proof signing key.
      *
@@ -3766,195 +3743,195 @@ type AssetKind = (typeof AssetKind)[keyof typeof AssetKind];
  */
 interface AssetVersionFile {
     /** Prefix for file URLs */
-    prefix?: string;
+    Prefix?: string;
     /** List of file paths */
-    fileRelativePaths?: string[];
+    FileRelativePaths?: string[];
 }
 /**
  * Asset play statistics.
  */
 interface PlayAssetStats {
     /** Number of plays */
-    playsRecent?: number;
+    PlaysRecent?: number;
     /** All-time plays */
-    playsAllTime?: number;
+    PlaysAllTime?: number;
     /** Favorites count */
-    favorites?: number;
+    Favorites?: number;
     /** Average rating */
-    averageRating?: number;
+    AverageRating?: number;
     /** Number of ratings */
-    numberOfRatings?: number;
+    NumberOfRatings?: number;
     /** Parent asset ID (if this is a variant) */
-    parentAssetId?: string;
+    ParentAssetId?: string;
 }
 /**
  * Base asset properties.
  */
 interface AssetBase {
     /** Asset unique identifier */
-    assetId?: string;
+    AssetId?: string;
     /** Version identifier */
-    versionId?: string;
+    VersionId?: string;
     /** Combined asset version ID */
-    assetVersionId?: string;
+    AssetVersionId?: string;
     /** Public display name */
-    publicName?: string;
+    PublicName?: string;
     /** Internal name */
-    name?: string;
+    Name?: string;
     /** Description */
-    description?: string;
+    Description?: string;
     /** Inspection result code */
-    inspectionResult?: number;
+    InspectionResult?: number;
     /** Clone behavior setting */
-    cloneBehavior?: number;
+    CloneBehavior?: number;
     /** Asset home (where it's stored) */
-    assetHome?: number;
+    AssetHome?: number;
     /** Descriptive tags */
-    tags?: string[];
+    Tags?: string[];
     /** Contributors (XUIDs) */
-    contributors?: string[];
+    Contributors?: string[];
     /** File information */
-    files?: AssetVersionFile;
+    Files?: AssetVersionFile;
     /** Type of asset */
-    assetKind?: AssetKind;
+    AssetKind?: AssetKind;
     /** Display order */
-    order?: number;
+    Order?: number;
     /** Play statistics */
-    assetStats?: PlayAssetStats;
+    AssetStats?: PlayAssetStats;
     /** When published (ISO 8601) */
-    publishedDate?: string;
+    PublishedDate?: string;
     /** Version number */
-    versionNumber?: number;
+    VersionNumber?: number;
     /** Admin XUID */
-    admin?: string;
+    Admin?: string;
     /** Display owner override */
-    displayOwnerOverride?: string;
+    DisplayOwnerOverride?: string;
 }
 /**
  * UGC authoring asset.
  */
 interface AuthoringAsset extends AssetBase {
     /** Original author XUID */
-    originalAuthor?: string;
+    OriginalAuthor?: string;
     /** Whether it's readonly */
-    readonly?: boolean;
+    Readonly?: boolean;
     /** Custom data for the asset type */
-    customData?: Record<string, unknown>;
+    CustomData?: Record<string, unknown>;
     /** Creation time (ISO 8601) */
-    createdAt?: string;
+    CreatedAt?: string;
     /** Last modification time (ISO 8601) */
-    updatedAt?: string;
+    UpdatedAt?: string;
 }
 /**
  * Authoring asset version.
  */
 interface AuthoringAssetVersion extends AssetBase {
     /** Readonly status */
-    readonly?: boolean;
+    Readonly?: boolean;
     /** Custom data */
-    customData?: Record<string, unknown>;
+    CustomData?: Record<string, unknown>;
 }
 /**
  * Container for multiple authoring assets.
  */
 interface AuthoringAssetContainer {
     /** Asset count */
-    count?: number;
+    Count?: number;
     /** Total available */
-    total?: number;
+    Total?: number;
     /** List of assets */
-    results?: AuthoringAsset[];
+    Results?: AuthoringAsset[];
     /** Pagination links */
-    links?: AssetLinks;
+    Links?: AssetLinks;
 }
 /**
  * Container for asset versions.
  */
 interface AuthoringAssetVersionContainer {
     /** List of versions */
-    results?: AuthoringAssetVersion[];
+    Results?: AuthoringAssetVersion[];
 }
 /**
  * Pagination links.
  */
 interface AssetLinks {
     /** Link to current page */
-    self?: string;
+    Self?: string;
     /** Link to next page */
-    next?: string;
+    Next?: string;
     /** Link to previous page */
-    prev?: string;
+    Prev?: string;
 }
 /**
  * Asset rating.
  */
 interface AuthoringAssetRating {
     /** User's rating value (1-5) */
-    rating?: number;
+    Rating?: number;
     /** When rated (ISO 8601) */
-    timestamp?: string;
+    Timestamp?: string;
 }
 /**
  * Favorite asset reference.
  */
 interface FavoriteAsset {
     /** Asset ID */
-    assetId?: string;
+    AssetId?: string;
     /** Asset kind */
-    assetKind?: AssetKind;
+    AssetKind?: AssetKind;
     /** When favorited (ISO 8601) */
-    favoritedAt?: string;
+    FavoritedAt?: string;
 }
 /**
  * Container for favorite assets.
  */
 interface AuthoringFavoritesContainer {
     /** List of favorites */
-    results?: FavoriteAsset[];
+    Results?: FavoriteAsset[];
     /** Total count */
-    total?: number;
+    Total?: number;
 }
 /**
  * Permission for an asset.
  */
 interface Permission {
     /** Player XUID */
-    player?: string;
+    Player?: string;
     /** Permission type */
-    permissionType?: string;
+    PermissionType?: string;
     /** Whether permission is granted */
-    granted?: boolean;
+    Granted?: boolean;
 }
 /**
  * Asset report for moderation.
  */
 interface AssetReport {
     /** Report reason */
-    reason?: string;
+    Reason?: string;
     /** Additional details */
-    details?: string;
+    Details?: string;
     /** When reported (ISO 8601) */
-    timestamp?: string;
+    Timestamp?: string;
 }
 /**
  * Authoring session for asset editing.
  */
 interface AssetAuthoringSession {
     /** Session identifier */
-    sessionId?: string;
+    SessionId?: string;
     /** Session expiration (ISO 8601) */
-    expiresAt?: string;
+    ExpiresAt?: string;
     /** Container SAS URL for uploads */
-    containerSas?: string;
+    ContainerSas?: string;
 }
 /**
  * Session starter for creating new versions.
  */
 interface AuthoringSessionSourceStarter {
     /** Source asset ID (to clone from) */
-    sourceAssetId?: string;
+    SourceAssetId?: string;
     /** Source version ID */
-    sourceVersionId?: string;
+    SourceVersionId?: string;
 }
 
 /**
@@ -3976,129 +3953,129 @@ type ResultOrder = (typeof ResultOrder)[keyof typeof ResultOrder];
  */
 interface UgcSearchParams {
     /** Search term */
-    term?: string;
+    Term?: string;
     /** Asset kinds to include */
-    assetKinds?: AssetKind[];
+    AssetKinds?: AssetKind[];
     /** Tags to filter by */
-    tags?: string[];
+    Tags?: string[];
     /** Author XUID */
-    author?: string;
+    Author?: string;
     /** Sort field */
-    sort?: string;
+    Sort?: string;
     /** Sort order */
-    order?: ResultOrder;
+    Order?: ResultOrder;
     /** Number of results to return */
-    count?: number;
+    Count?: number;
     /** Starting offset */
-    start?: number;
+    Start?: number;
 }
 /**
  * Search result container.
  */
 interface UgcSearchResult {
     /** Search results */
-    results?: AuthoringAsset[];
+    Results?: AuthoringAsset[];
     /** Total matching results */
-    totalCount?: number;
+    TotalCount?: number;
     /** Returned count */
-    count?: number;
+    Count?: number;
     /** Starting offset */
-    start?: number;
+    Start?: number;
     /** Pagination links */
-    links?: SearchLinks;
+    Links?: SearchLinks;
 }
 /**
  * Search pagination links.
  */
 interface SearchLinks {
     /** Current page */
-    self?: string;
+    Self?: string;
     /** Next page */
-    next?: string;
+    Next?: string;
     /** Previous page */
-    prev?: string;
+    Prev?: string;
 }
 /**
  * Map variant asset.
  */
-interface MapAsset extends Omit<AuthoringAsset, 'customData'> {
+interface MapAsset extends Omit<AuthoringAsset, 'CustomData'> {
     /** Map-specific custom data */
-    customData?: MapCustomData;
+    CustomData?: MapCustomData;
 }
 /**
  * Map custom data.
  */
 interface MapCustomData {
     /** Number of supported players */
-    supportedPlayerCount?: number;
+    SupportedPlayerCount?: number;
     /** Recommended player count */
-    recommendedPlayerCount?: number;
+    RecommendedPlayerCount?: number;
     /** Budget usage */
-    budgetUsed?: number;
+    BudgetUsed?: number;
     /** Object count */
-    objectCount?: number;
+    ObjectCount?: number;
     /** Has lightmap */
-    hasLightmap?: boolean;
+    HasLightmap?: boolean;
 }
 /**
  * Game variant asset.
  */
-interface UgcGameVariantAsset extends Omit<AuthoringAsset, 'customData'> {
+interface UgcGameVariantAsset extends Omit<AuthoringAsset, 'CustomData'> {
     /** Game variant custom data */
-    customData?: GameVariantCustomData;
+    CustomData?: GameVariantCustomData;
 }
 /**
  * Game variant custom data.
  */
 interface GameVariantCustomData {
     /** Game variant category */
-    category?: number;
+    Category?: number;
     /** Score to win */
-    scoreToWin?: number;
+    ScoreToWin?: number;
     /** Time limit */
-    timeLimit?: number;
+    TimeLimit?: number;
     /** Rounds to win */
-    roundsToWin?: number;
+    RoundsToWin?: number;
     /** Max players */
-    maxPlayers?: number;
+    MaxPlayers?: number;
     /** Min players */
-    minPlayers?: number;
+    MinPlayers?: number;
 }
 /**
  * Film asset (theater recording).
  */
-interface FilmAsset extends Omit<AuthoringAsset, 'customData'> {
+interface FilmAsset extends Omit<AuthoringAsset, 'CustomData'> {
     /** Film custom data */
-    customData?: FilmCustomData;
+    CustomData?: FilmCustomData;
 }
 /**
  * Film custom data.
  */
 interface FilmCustomData {
     /** Match ID this film is from */
-    matchId?: string;
+    MatchId?: string;
     /** Duration of the film */
-    duration?: string;
+    Duration?: string;
     /** Map asset ID */
-    mapAssetId?: string;
+    MapAssetId?: string;
     /** Game variant asset ID */
-    gameVariantAssetId?: string;
+    GameVariantAssetId?: string;
 }
 /**
  * Prefab asset.
  */
-interface PrefabAsset extends Omit<AuthoringAsset, 'customData'> {
+interface PrefabAsset extends Omit<AuthoringAsset, 'CustomData'> {
     /** Prefab custom data */
-    customData?: PrefabCustomData;
+    CustomData?: PrefabCustomData;
 }
 /**
  * Prefab custom data.
  */
 interface PrefabCustomData {
     /** Object count */
-    objectCount?: number;
+    ObjectCount?: number;
     /** Budget usage */
-    budgetUsed?: number;
+    BudgetUsed?: number;
 }
 
 /**
@@ -4337,7 +4314,7 @@ declare class UgcModule extends ModuleBase {
      * @param includeContainerSas - Include container SAS URL
      * @returns Session details
      */
-    startSession(title: string, assetType: string, assetId: string, includeContainerSas?: boolean): Promise<HaloApiResult<AssetAuthoringSession>>;
+    startSession(title: string, assetType: string, assetId: string, starter?: AuthoringSessionSourceStarter, includeContainerSas?: boolean): Promise<HaloApiResult<AssetAuthoringSession>>;
     /**
      * Extend an authoring session.
      *
@@ -4401,8 +4378,6 @@ declare class UgcModule extends ModuleBase {
  *
  * Provides access to:
  * - Searching for maps, game variants, and other content
- * - Browsing featured and popular content
- * - Getting recommended content
  * - Getting specific asset types (maps, playlists, prefabs, etc.)
  *
  * @example
@@ -4416,9 +4391,6 @@ declare class UgcModule extends ModuleBase {
  *
  * // Get a specific map
  * const map = await client.ugcDiscovery.getMap('asset-id', 'version-id');
- *
- * // Get featured maps
- * const featured = await client.ugcDiscovery.getFeatured('Map');
  * ```
  */
 declare class UgcDiscoveryModule extends ModuleBase {
@@ -4461,58 +4433,6 @@ declare class UgcDiscoveryModule extends ModuleBase {
         /** Maximum date published */
         toDatePublishedUtc?: Date;
     }): Promise<HaloApiResult<UgcSearchResult>>;
-    /**
-     * Get featured content of a specific type.
-     *
-     * @param assetKind - Type of asset
-     * @returns Featured assets
-     */
-    getFeatured(assetKind: string): Promise<HaloApiResult<UgcSearchResult>>;
-    /**
-     * Get popular content of a specific type.
-     *
-     * @param assetKind - Type of asset
-     * @param start - Starting offset
-     * @param count - Number of results
-     * @returns Popular assets
-     */
-    getPopular(assetKind: string, start?: number, count?: number): Promise<HaloApiResult<UgcSearchResult>>;
-    /**
-     * Get recent content of a specific type.
-     *
-     * @param assetKind - Type of asset
-     * @param start - Starting offset
-     * @param count - Number of results
-     * @returns Recent assets
-     */
-    getRecent(assetKind: string, start?: number, count?: number): Promise<HaloApiResult<UgcSearchResult>>;
-    /**
-     * Get recommended content for a player.
-     *
-     * @param player - Player XUID
-     * @param assetKind - Type of asset
-     * @param count - Number of results
-     * @returns Recommended assets
-     */
-    getRecommended(player: string, assetKind: string, count?: number): Promise<HaloApiResult<UgcSearchResult>>;
-    /**
-     * Browse content by tag.
-     *
-     * @param assetKind - Type of asset
-     * @param tag - Tag to filter by
-     * @param start - Starting offset
-     * @param count - Number of results
-     * @returns Tagged assets
-     */
-    browseByTag(assetKind: string, tag: string, start?: number, count?: number): Promise<HaloApiResult<UgcSearchResult>>;
-    /**
-     * Get asset details for discovery purposes.
-     *
-     * @param assetKind - Type of asset
-     * @param assetId - Asset GUID
-     * @returns Asset details
-     */
-    getAssetDetails(assetKind: string, assetId: string): Promise<HaloApiResult<AuthoringAsset>>;
     /**
      * Get tags information.
      *